function JITHTTPCLIENT() {
   // var xmlHttp = null;
    //var url = "http://192.168.0.51:8000";
    var url = "http://127.0.0.1:45679";
    //var url = "https://127.0.0.1:45680";  //https
    var FinalizeCmd = "{\"name\": \"Finalize\"}";
    var ClearPinCodeCmd = "{\"name\": \"ClearPinCode\"}";
    var GeterrocodeCmd = "{\"name\": \"GetErrorCode\"}";
    var GetDataCmd = "{\"name\": \"GetData\"}";
    var GetVersionCmd = "{\"name\": \"JITGetVersion\"}";
    var GetMacCmd = "{\"name\": \"JITGetMAC\"}";
    var ReStartServerCmd = "{\"name\": \"ReStartSever\"}";

    function validataOS() {
        if (navigator.userAgent.indexOf("Window") > 0) {
            return "Windows";
        } else if (navigator.userAgent.indexOf("Mac OS X") > 0) {
            return "Mac ";
        } else if (navigator.userAgent.indexOf("Linux") > 0) {
            return "Linux";
        } else {
            return "NUll";
        }
    }

    if (validataOS() == "Windows") {
        var strinit = new Array("", "R0FLRVlfU0tGLmRsbA==", "bXRva2VuX2dtMzAwMF9KSVQuZGxs", "bXRva2VuX2dtMzAwMC5kbGw=", "bXRva2VuX2dtMzAwMF9leC5kbGw=", "SERfR01DQUlTLmRsbA==", "U2h1dHRsZUNzcDExXzMwMDBHTS5kbGw=", "SklUR01LRVlfU0pLMTQyNC5kbGw=", "U0tGQVBJMjAwNzkuZGxs", "U0tGQVBJMzA3MTAuZGxs", "U0tGQVBJNDAwOTcuZGxs", "U0tGQVBJLmRsbA==", "U3hjYUNzcDExXzMwMDBHTV9zLmRsbA==", "U21hcnRDVENBUElISUQuZGxs", "RlJJRHJpdmVyU0tGMi5kbGw=", "U3hjYUNzcDExXzMwMDBHTS5kbGw=", "V0RTS0ZfQ05QQ3Y1LjEuZGxs", "U0tGX0lCLmRsbA==", "Sml0M2tHTVAxMVYyMTEuZGxs");
       // var strnameinit = new Array("证书软证", "公安驱动", "龙脉驱动", "龙脉", "龙脉", "HD_GMCAIS.dll", "飞天标准key", "飞天OEMkey", "海泰20079", "海泰30710", "海泰40097", "海泰", "SxcaCsp11_3000GM_s.dll", "中孚", "FRIDriverSKF2.dll", "SxcaCsp11_3000GM.dll", "WDSKF_CNPCv5.1.dll", "一元", "南网key");
        //支持初始化参数摘要算法传入空值，默认SHA1，SM2，如需要设置其它摘要算法可以在初始化接口参数中进行设置
        //提示：设置摘要参数时注意，winxp,win7只支持sha1。
        //CSP: windows加密库接口
        //SKF: key加密库接口
        //产品接入时注意不要加载以下全部驱动，只加载相应key驱动即可，否则影响性能
        //相同Key厂家的驱动不要加载多个不同版本，否则有可能会出现驱动不兼容现象

        var strinitParam = "<?xml version=\"1.0\" encoding=\"utf-8\"?>" +
            "<authinfo><liblist>" +
            "<lib type=\"CSP\" version=\"1.0\" dllname=\"\" ><algid val=\"SHA1\" sm2_hashalg=\"sm3\"/></lib>" +
            "<lib type=\"SKF\" version=\"1.1\" dllname=\"R0FLRVlfU0tGLmRsbA==\" ><algid val=\"SHA1\" sm2_hashalg=\"sm3\"/></lib>" + //GAKEY_SKF.dll    公安驱动
            "<lib type=\"SKF\" version=\"1.1\" dllname=\"bXRva2VuX2dtMzAwMF9KSVQuZGxs\" ><algid val=\"SHA1\" sm2_hashalg=\"sm3\"/></lib>" + //mtoken_gm3000_JIT.dll  龙脉驱动
            "<lib type=\"SKF\" version=\"1.1\" dllname=\"SERfR01DQUlTLmRsbA==\" ><algid val=\"SHA1\" sm2_hashalg=\"sm3\"/></lib>" + //HD_GMCAIS.dll
            "<lib type=\"SKF\" version=\"1.1\" dllname=\"U2h1dHRsZUNzcDExXzMwMDBHTS5kbGw=\" ><algid val=\"SHA1\" sm2_hashalg=\"sm3\"/></lib>" + //ShuttleCsp11_3000GM.dll 	飞天标准key
            "<lib type=\"SKF\" version=\"1.1\" dllname=\"SklUR01LRVlfU0pLMTQyNC5kbGw=\" ><algid val=\"SHA1\" sm2_hashalg=\"sm3\"/></lib>" + //JITGMKEY_SJK1424.dll		飞天OEMkey
            "<lib type=\"SKF\" version=\"1.1\" dllname=\"U0tGQVBJMjAwNzkuZGxs\" ><algid val=\"SHA1\" sm2_hashalg=\"sm3\"/></lib>" + //SKFAPI20079.dll			海泰20079
            "<lib type=\"SKF\" version=\"1.1\" dllname=\"U0tGQVBJMzA3MTAuZGxs\" ><algid val=\"SHA1\" sm2_hashalg=\"sm3\"/></lib>" + //SKFAPI30710.dll			海泰30710
            "<lib type=\"SKF\" version=\"1.1\" dllname=\"U0tGQVBJNDAwOTcuZGxs\" ><algid val=\"SHA1\" sm2_hashalg=\"sm3\"/></lib>" + //SKFAPI40097.dll			海泰40097
            "<lib type=\"SKF\" version=\"1.1\" dllname=\"U0tGQVBJLmRsbA==\" ><algid val=\"SHA1\" sm2_hashalg=\"sm3\"/></lib>" + //SKFAPI.dll
            "<lib type=\"SKF\" version=\"1.1\" dllname=\"U3hjYUNzcDExXzMwMDBHTV9zLmRsbA==\" ><algid val=\"SHA1\" sm2_hashalg=\"sm3\"/></lib>" + //SxcaCsp11_3000GM_s.dll
            "<lib type=\"SKF\" version=\"1.1\" dllname=\"bXRva2VuX2dtMzAwMC5kbGw=\" ><algid val=\"SHA1\" sm2_hashalg=\"sm3\"/></lib>" + //mtoken_gm3000.dll			龙脉
            "<lib type=\"SKF\" version=\"1.1\" dllname=\"U21hcnRDVENBUElISUQuZGxs\" ><algid val=\"SHA1\" sm2_hashalg=\"sm3\"/></lib>" + //SmartCTCAPIHID.dll		中孚
            "<lib type=\"SKF\" version=\"1.1\" dllname=\"RlJJRHJpdmVyU0tGMi5kbGw=\" ><algid val=\"SHA1\" sm2_hashalg=\"sm3\"/></lib>" + //FRIDriverSKF2.dll
            "<lib type=\"SKF\" version=\"1.1\" dllname=\"U3hjYUNzcDExXzMwMDBHTS5kbGw=\" ><algid val=\"SHA1\" sm2_hashalg=\"sm3\"/></lib>" + //SxcaCsp11_3000GM.dll
            "<lib type=\"SKF\" version=\"1.1\" dllname=\"V0RTS0ZfQ05QQ3Y1LjEuZGxs\" ><algid val=\"SHA1\" sm2_hashalg=\"sm3\"/></lib>" + //WDSKF_CNPCv5.1.dll
            "<lib type=\"SKF\" version=\"1.1\" dllname=\"U0tGX0lCLmRsbA==\" ><algid val=\"SHA1\" sm2_hashalg=\"sm3\"/></lib>" + //SKF_IB.dll				一元
            "<lib type=\"SKF\" version=\"1.1\" dllname=\"Sml0M2tHTVAxMVYyMTEuZGxs\" ><algid val=\"SHA1\" sm2_hashalg=\"sm3\"/></lib>" + //                          南网key
            "<lib type=\"SKF\" version=\"1.1\" dllname=\"bXRva2VuX2dtMzAwMF9leC5kbGw=\" ><algid val=\"SHA1\" sm2_hashalg=\"sm3\"/></lib>" + //                      龙脉
            "</liblist><checkkeytimes><item times=\"1\" ></item></checkkeytimes></authinfo>";
        var strinitParam3 = "<lib type=\"CSP\" version=\"1.0\" dllname=\"\" ><algid val=\"SHA1\" sm2_hashalg=\"sm3\"/></lib>";
    } else {
        var strinitParam = "<?xml version=\"1.0\" encoding=\"utf-8\"?>" +
            "<authinfo><liblist>" +
            "<lib type=\"SKF\" version=\"1.1\" dllname=\"L3Vzci9saWIvbGliU0tGQVBJLnNv\" ><algid val=\"SHA1\" sm2_hashalg=\"sm3\"/></lib>" + ///usr/lib/libSKFAPI.so 海泰key
            "<lib type=\"SKF\" version=\"1.1\" dllname=\"bGliU0tGQVBJLXg2NC5zbw==\" ><algid val=\"SHA1\" sm2_hashalg=\"sm3\"/></lib>" + //libSKFAPI-x64.so 海泰key
            "<lib type=\"SKF\" version=\"1.1\" dllname=\"L2hvbWUvenEvU0tG5a+G56CB5bqTL2ltcG9ydENlcnRfbGludXgvbGliaml0c2tmbW9kdWxlLnNv\" ><algid val=\"SHA1\" sm2_hashalg=\"sm3\"/></lib>" + //libSKFAPI-x64.so 海泰key
            "<lib type=\"SKF\" version=\"1.1\" dllname=\"bGliU0tGQVBJLW1pcHM2NGwtbG9nLnNv\" ><algid val=\"SHA1\" sm2_hashalg=\"\"/></lib>" + //libSKFAPI-mips64l-log.so 海泰key
            "<lib type=\"SKF\" version=\"1.1\" dllname=\"bGliU0tGQVBJLWFybTY0LWxvZy5zbw==\" ><algid val=\"SHA1\" sm2_hashalg=\"sm3\"/></lib>" + //libSKFAPI-arm64-log.so 海泰key
            "<lib type=\"SKF\" version=\"1.1\" dllname=\"bGliZXNfMzAwMGdtLnNv\" ><algid val=\"SHA1\" sm2_hashalg=\"sm3\"/></lib>" + //libes_3000gm.so 飞天key
            "<lib type=\"SKF\" version=\"1.1\" dllname=\"bGliU0tGQVBJLWFybTY0LnNv\" ><algid val=\"SHA1\" sm2_hashalg=\"sm3\"/></lib>" + //libSKFAPI-arm64.so
            "<lib type=\"SKF\" version=\"1.1\" dllname=\"bGlic21hcnRjdGNhcGkuc28=\" ><algid val=\"SHA1\" sm2_hashalg=\"sm3\"/></lib>" + // libsmartctcapi.so 中孚key
            "<lib type=\"SKF\" version=\"1.1\" dllname=\"Z20zMDAwLTEuMC1GVC42NC5kZWI=\" ><algid val=\"SHA1\" sm2_hashalg=\"sm3\"/></lib>" + //gm3000-1.0-FT.64.deb
            "<lib type=\"SKF\" version=\"1.1\" dllname=\"bGliZXNfMzAwMGdtLnNvLjEuMC4w\" ><algid val=\"SHA1\" sm2_hashalg=\"sm3\"/></lib>" + //libes_3000gm.so.1.0.0
            "<lib type=\"SKF\" version=\"1.1\" dllname=\"bGliU0tGQVBJLXg4Ni1sb2cuc28=\" ><algid val=\"SHA1\" sm2_hashalg=\"sm3\"/></lib>" + //libSKFAPI-x86-log.so
            "<lib type=\"SKF\" version=\"1.1\" dllname=\"bGliU0tGSW50ZXJmYWNlLnNv=\" ><algid val=\"SHA1\" sm2_hashalg=\"sm3\"/></lib>" + //libSKFInterface.so 赢达信
            "<lib type=\"SKF\" version=\"1.1\" dllname=\"bGliZXNfMzAwMGdtX0pJVC5zbw==\" ><algid val=\"SHA1\" sm2_hashalg=\"sm3\"/></lib>" + //libes_3000gm_JIT.so
            "<lib type=\"SKF\" version=\"1.1\" dllname=\"L2xpYi9saWJTS0ZBUEkuc28=\" ><algid val=\"SHA1\" sm2_hashalg=\"sm3\"/></lib>" + ///lib/libSKFAPI.so
            "</liblist><checkkeytimes><item times=\"1\" ></item></checkkeytimes></authinfo>";
    }
    var strinitParam1 = "<?xml version=\"1.0\" encoding=\"utf-8\"?>" +
        "<authinfo><liblist>" + ""
    var strinitParam2 = "</liblist><checkkeytimes><item times=\"1\" ></item></checkkeytimes></authinfo>";
    var strinitParam_1 = "<lib type=\"SKF\" version=\"1.1\" dllname=\"";
    var strinitParam_2 = "\" ><algid val=\"SHA1\" sm2_hashalg=\"sm3\"/></lib>";
    var mHashAlgName = "";

    function createXHR() {
        if (typeof XMLHttpRequest != "undefined") {
            //alert(1);
            return new XMLHttpRequest(); //IE7+和其他浏览器支持的
        } else if (typeof ActiveXObject != "undefined") { //IE7-支持的
            if (typeof arguments.callee.activeXString != "string") {
                var versions = ["MSXML2.XMLHttp.6.0", "MSXML2.XMLHttp.3.0", "MSXML2.XMLHttp"],
                    i, len;
                for (i = 0, len = versions.length; i < len; i++) {
                    try {
                        new ActiveXObject(versions[i]);
                        arguments.callee.activeXString = versions[i];
                        alert(arguments.callee.activeXString);
                        break;
                    } catch (e) {
                        alert(e.message);
                    }
                }
            }
            return new ActiveXObject(arguments.callee.activeXString); //返回ActiveXObject对象
        } else { //全部不支持，抛出错误
            throw new Error("don't support XMLHttpRequest");
        }
    }

    function DisConn() {
       
    }

    function Ajax(senddata) {
        var errormsg = "{\"error\":999,\"value\":\"与服务断开连接\"}";
        //1.创建Ajax对象
        var xmlHttp = createXHR();

        //2.连接服务器 open方法只是启动一个请求以备发送，还未发送
        xmlHttp.open("POST", url, false); //false: 同步

        //打开下面这句可以测试chrome OPTIONS 跨域
        //xmlHttp.setRequestHeader('content-type','application/json');

        //3.发送请求
        try {
            //consol+e.log("senddata: " + senddata);
            xmlHttp.send(senddata);
        } catch (e) {
            console.log("DisConn Exception: " + e + ", status = " + xmlHttp.status + ", responseText: " + xmlHttp.responseText);
            //DisConn();
            xmlHttp.abort();
            return errormsg;
        };

        //4.接收返回值 和服务器通讯的时候此事件发生
        if (xmlHttp.readyState == 4 && (xmlHttp.status == 200 || xmlHttp.status == 0)) {
            if (xmlHttp.responseText == null) {
                console.log("xmlHttp.responseText: ");
                return errormsg;
            }
            return xmlHttp.responseText;
        } else {
            //console.log("return: " + xmlHttp.status + "===" + senddata + "===" + xmlHttp.responseText + "===" + xmlHttp.readyState);
            return errormsg;
        }
    }

    function _Getretcode(Cmdname) {
        var ret = -1;
        var str = Ajax(Cmdname);
        ret = JSON.parse(str).error;
        mHashAlgName = JSON.parse(str).HashAlgName;
        return ret;
    }

    function _GetTsaHashAlgName() {
        return mHashAlgName;
    }

    function _Getretmsg(Cmdname) {
        var ret = "";
        var str = Ajax(Cmdname);
        ret = JSON.parse(str).value;
        return ret;
    }

    function _Getretvalue(Cmdname) {
        var ret = "";
        var str = Ajax(Cmdname);
        ret="返回信息:"+JSON.parse(str).value+"返回错误码:"+JSON.parse(str).error;
        return ret;
    }


    return {
        StrInit: strinit,
        strinitParam_1: strinitParam_1,
        strinitParam_2: strinitParam_2,
        mHashAlgName: mHashAlgName,
        _Getretmsg: _Getretmsg,
        _Getretcode: _Getretcode,

        JitReadFile1: function (bstrFileName, nIsBase64) {
            var JitReadFile1Cmd = {
                name: "JitReadFile1",
                p1: bstrFileName,
                p2: nIsBase64
            };
            var JitReadFile1CmdJson = JSON.stringify(JitReadFile1Cmd);
            return _Getretmsg(JitReadFile1CmdJson);
        },
        Initialize: function () {
            var InitCmd = {
                name: "Initialize",
                p1: strinitParam
            };
            var InitCmdJson = JSON.stringify(InitCmd); //转换为json字符串
            return _Getretcode(InitCmdJson);
        },
        Finalize: function () {
            return _Getretcode(FinalizeCmd);
        },
        RegisterParam: function () {
            var RegisterParamCmd = {
                name: "RegisterParam",
                p1: strinitParam
            };
            var RegisterParamCmdJson = JSON.stringify(RegisterParamCmd); //转换为json字符串
            return _Getretcode(RegisterParamCmdJson);
        },
        RegisterParamOne: function (strInit) {
            var str = "" + strinitParam1 + strinitParam_1 + strInit + strinitParam_2 + strinitParam2;
            var RegisterParamCmd = {
                name: "RegisterParam",
                p1: str
            };
            var RegisterParamCmdJson = JSON.stringify(RegisterParamCmd); //转换为json字符串
            return _Getretcode(RegisterParamCmdJson);
        },
        RegisterParamMore: function (str) {
            var RegisterParamCmd = {
                name: "RegisterParam",
                p1: str
            };
            var RegisterParamCmdJson = JSON.stringify(RegisterParamCmd); //转换为json字符串
            return _Getretcode(RegisterParamCmdJson);
        },
        GetErrorCode: function () {
            return _Getretcode(GeterrocodeCmd);
        },
        GetErrorMessage: function (errorcode) {
            var GetErrorMessageCmd = {
                name: "GetErrorMessage",
                p1: errorcode
            };
            var GetErrorMessageCmdJson = JSON.stringify(GetErrorMessageCmd);
            return _Getretmsg(GetErrorMessageCmdJson);
        },
        VerifyPinCode: function (strPinCode, strNewPinCode) {
            var VerifyPinCodeCmd = {
                name: "VerifyPinCode",
                p1: strPinCode,
                p2: strNewPinCode
            };
            var VerifyPinCodeCmdJson = JSON.stringify(VerifyPinCodeCmd);
            return _Getretcode(VerifyPinCodeCmdJson);
        },
        //org
        SetCertChooseType: function (types) {
            var SetCertChooseTypeCmd = {
                name: "SetCertChooseType",
                p1: types
            };
            var SetCertChooseTypeCmdJson = JSON.stringify(SetCertChooseTypeCmd);
            return _Getretcode(SetCertChooseTypeCmdJson);
        },
        ClearPinCode: function () {
            return _Getretcode(ClearPinCodeCmd);
        },
        SetPinCode: function (strpincode) {
            var SetPinCodeCmd = {
                name: "SetPinCode",
                p1: strpincode
            };
            var SetPinCodeCmdJson = JSON.stringify(SetPinCodeCmd);
            return _Getretcode(SetPinCodeCmdJson);
        },
        JITEnablePinDialog: function (types) {
            var SetEnablePinDialogCmd = {
                name: "SetEnablePinDialog",
                p1: types
            };
            var SetEnablePinDialogCmdJson = JSON.stringify(SetEnablePinDialogCmd);
            return _Getretcode(SetEnablePinDialogCmdJson);
        },
		JITForcePinDialog: function (types) {
            var SetForcePinDialogCmd = {
                name: "SetForcePinDialog",
                p1: types
            };
            var SetForcePinDialogCmdJson = JSON.stringify(SetForcePinDialogCmd);
            return _Getretcode(SetForcePinDialogCmdJson);
        },
        SetCert: function (strCertType, strDN, strSN, strEmail, strDNIssuer, strCertBase64) {
            var SetCertCmd = {
                name: "SetCert",
                p1: strCertType,
                p2: strDN,
                p3: strSN,
                p4: strEmail,
                p5: strDNIssuer,
                p6: strCertBase64
            };
            var SetCertCmdJson = JSON.stringify(SetCertCmd);
            return _Getretcode(SetCertCmdJson);
        },
        SetCert2: function (strCertType, strDN, strSN, strEmail, strDNIssuer, strCertBase64, strCertNameType) {
            var SetCert2Cmd = {
                name: "SetCert2",
                p1: strCertType,
                p2: strDN,
                p3: strSN,
                p4: strEmail,
                p5: strDNIssuer,
                p6: strCertBase64,
                p7: strCertNameType
            };
            var SetCert2CmdJson = JSON.stringify(SetCert2Cmd);
            return _Getretcode(SetCert2CmdJson);
        },
        SetCert3: function (strCertType, strDN, strSN, strEmail, strDNIssuer, strCertBase64, strCertNameType,bstrKeyType) {
            var SetCert3Cmd = {
                name: "SetCert3",
                p1: strCertType,
                p2: strDN,
                p3: strSN,
                p4: strEmail,
                p5: strDNIssuer,
                p6: strCertBase64,
                p7: strCertNameType,
                p8:bstrKeyType
            };
            var SetCert3CmdJson = JSON.stringify(SetCert3Cmd);
            return _Getretcode(SetCert3CmdJson);
        },
        SetCert6: function (strCertType, strDN, strSN, strEmail, strDNIssuer, strCertBase64, strCertNameType,bstrKeyType) {
            var SetCert6Cmd = {
                name: "SetCert6",
                p1: strCertType,
                p2: strDN,
                p3: strSN,
                p4: strEmail,
                p5: strDNIssuer,
                p6: strCertBase64,
                p7: strCertNameType,
                p8:bstrKeyType
            };
            var SetCert6CmdJson = JSON.stringify(SetCert6Cmd);
            return _Getretcode(SetCert6CmdJson);
        },
        SetCertEx: function (strCertStoreType, strCertType, strDN, strSN, strEmail, strDNIssuer, strCertBase64) {
            var SetCertExCmd = {
                name: "SetCertEx",
                p1: strCertStoreType,
                p2: strCertType,
                p3: strDN,
                p4: strSN,
                p5: strEmail,
                p6: strDNIssuer,
                p7: strCertBase64
            };
            var SetCertExCmdJson = JSON.stringify(SetCertExCmd);
            return _Getretcode(SetCertExCmdJson);
        },
        P1SignStr: function (strdn, strsrc) {
            var P1SignStrCmd = {
                name: "P1SignStr",
                p1: strdn,
                p2: strsrc
            };
            var P1SignStrCmdJson = JSON.stringify(P1SignStrCmd); //转换为json字符串
            return _Getretmsg(P1SignStrCmdJson);
        },
        AttachSignStr: function (strdn, strsrc) {
            var AttachSignStrCmd = {
                name: "AttachSignStr",
                p1: strdn,
                p2: strsrc
            };
            var AttachSignStrCmdJson = JSON.stringify(AttachSignStrCmd); //转换为json字符串
            return _Getretmsg(AttachSignStrCmdJson);
        },
        AttachSignBase64Str: function (strdn, strsrc,nIsBase64) {
            var AttachSignBase64StrCmd = {
                name: "AttachSignBase64Str",
                p1: strdn,
                p2: strsrc,
                p3:nIsBase64
            };
            var AttachSignBase64StrCmdJson = JSON.stringify(AttachSignBase64StrCmd); //转换为json字符串
            return _Getretmsg(AttachSignBase64StrCmdJson);
        },
        DetachSignStr: function (strdn, strsrc) {
            var DetachSignStrCmd = {
                name: "DetachSignStr",
                p1: strdn,
                p2: strsrc
            };
            var DetachSignStrCmdJson = JSON.stringify(DetachSignStrCmd); //转换为json字符串
            return _Getretmsg(DetachSignStrCmdJson);
        },
        DetachSignBase64Str: function (strdn, strsrc,nIsBase64) {
            var DetachSignBase64StrCmd = {
                name: "DetachSignBase64Str",
                p1: strdn,
                p2: strsrc,
                p3:nIsBase64
            };
            var DetachSignBase64StrCmdJson = JSON.stringify(DetachSignBase64StrCmd); //转换为json字符串
            return _Getretmsg(DetachSignBase64StrCmdJson);
        },
        VerifyAttachedSign: function (strSignedData) {
            var VerifyAttachedSignCmd = {
                name: "VerifyAttachedSign",
                p1: strSignedData
            };
            var VerifyAttachedSignCmdJson = JSON.stringify(VerifyAttachedSignCmd);
            return _Getretcode(VerifyAttachedSignCmdJson);
        },
        JITGVerifyAttachedSignStr: function (strSignedData) {
            var JITGVerifyAttachedSignStrCmd = {
                name: "JITGVerifyAttachedSignStr",
                p1: strSignedData
            };
            var JITGVerifyAttachedSignStrCmdJson = JSON.stringify(JITGVerifyAttachedSignStrCmd);
            return _Getretcode(JITGVerifyAttachedSignStrCmdJson);
        },
        VerifyDetachedSignStr: function (strSignedData, strsrc) {
            var VerifyDetachedSignStrCmd = {
                name: "VerifyDetachedSignStr",
                p1: strSignedData,
                p2: strsrc
            };
            var VerifyDetachedSignStrCmdJson = JSON.stringify(VerifyDetachedSignStrCmd);
            return _Getretcode(VerifyDetachedSignStrCmdJson);
        },
        JITGVerifyDetachedSignStr: function (strSignedData, strsrc) {
            var JITGVerifyDetachedSignStrCmd = {
                name: "JITGVerifyDetachedSignStr",
                p1: strSignedData,
                p2: strsrc
            };
            var JITGVerifyDetachedSignStrCmdJson = JSON.stringify(JITGVerifyDetachedSignStrCmd);
            return _Getretcode(JITGVerifyDetachedSignStrCmdJson);
        },
        EncryptEnvelopStr: function (strdn, strsrc) {
            var EncryptEnvelopStrCmd = {
                name: "EncryptEnvelopStr",
                p1: strdn,
                p2: strsrc
            };
            var EncryptEnvelopStrCmdJson = JSON.stringify(EncryptEnvelopStrCmd); //转换为json字符串
            return _Getretmsg(EncryptEnvelopStrCmdJson);
        },
        EncryptEnvelopBase64Str: function (strdn, strsrc,nIsBase64) {
            var EncryptEnvelopBase64StrCmd = {
                name: "EncryptEnvelopBase64Str",
                p1: strdn,
                p2: strsrc,
                p3: nIsBase64
            };
            var EncryptEnvelopBase64StrCmdJson = JSON.stringify(EncryptEnvelopBase64StrCmd); //转换为json字符串
            return _Getretmsg(EncryptEnvelopBase64StrCmdJson);
        },
        DecryptEnvelop: function (strEnvelop) {
            var DecryptEnvelopCmd = {
                name: "DecryptEnvelop",
                p1: strEnvelop
            };
            var DecryptEnvelopCmdJson = JSON.stringify(DecryptEnvelopCmd);
            return _Getretcode(DecryptEnvelopCmdJson);
        },
        Digest: function (strSrcData) {
            var DigestCmd = {
                name: "Digest",
                p1: strSrcData
            };
            var DigestCmdJson = JSON.stringify(DigestCmd);
            return _Getretmsg(DigestCmdJson);
        },
        CreateSignedEnvelopStr: function (strSignCertDN, strEncCertDN, strSrc) {
            var CreateSignedEnvelopStrCmd = {
                name: "CreateSignedEnvelopStr",
                p1: strSignCertDN,
                p2: strEncCertDN,
                p3: strSrc
            };
            var CreateSignedEnvelopStrCmdJson = JSON.stringify(CreateSignedEnvelopStrCmd); //转换为json字符串
            return _Getretmsg(CreateSignedEnvelopStrCmdJson);
        },
        CreateSignedEnvelopBase64Str: function (strSignCertDN, strEncCertDN, strSrc) {
            var CreateSignedEnvelopBase64StrCmd = {
                name: "CreateSignedEnvelopBase64Str",
                p1: strSignCertDN,
                p2: strEncCertDN,
                p3: strSrc
            };
            var CreateSignedEnvelopBase64StrCmdJson = JSON.stringify(CreateSignedEnvelopBase64StrCmd); //转换为json字符串
            return _Getretmsg(CreateSignedEnvelopBase64StrCmdJson);
        },
        VerifySignedEnvelop: function (strEnvelop) {
            var VerifySignedEnvelopCmd = {
                name: "VerifySignedEnvelop",
                p1: strEnvelop
            };
            var VerifySignedEnvelopCmdJson = JSON.stringify(VerifySignedEnvelopCmd);
            return _Getretcode(VerifySignedEnvelopCmdJson);
        },
        GetCertInfo: function (strCertType, lInfoType, strOID) {
            var GetCertInfoCmd = {
                name: "GetCertInfo",
                p1: strCertType,
                p2: lInfoType,
                p3: strOID
            };
            var GetCertInfoCmdJson = JSON.stringify(GetCertInfoCmd);
            return _Getretmsg(GetCertInfoCmdJson);
        },
        SetAlgorithm: function (strHashAlg, strEncAlg) {
            var SetAlgorithmCmd = {
                name: "SetAlgorithm",
                p1: strHashAlg,
                p2: strEncAlg
            };
            var SetAlgorithmCmdJson = JSON.stringify(SetAlgorithmCmd);
            return _Getretcode(SetAlgorithmCmdJson);
        },
        SymmetricEncrypt: function (strSymmetricKey, strSrcData, isPad) {
            var SymmetricEncryptCmd = {
                name: "SymmetricEncrypt",
                p1: strSymmetricKey,
                p2: strSrcData,
                p3: isPad
            };
            var SymmetricEncryptCmdJson = JSON.stringify(SymmetricEncryptCmd);
            return _Getretmsg(SymmetricEncryptCmdJson);
        },
        SymmetricDecrypt: function (strSymmetricKey, strEncryptData, isPad) {
            var SymmetricDecryptCmd = {
                name: "SymmetricDecrypt",
                p1: strSymmetricKey,
                p2: strEncryptData,
                p3: isPad
            };
            var SymmetricDecryptCmdJson = JSON.stringify(SymmetricDecryptCmd);
            return _Getretmsg(SymmetricDecryptCmdJson);
        },
        GetCertList: function (strCertType, strCertDN, strCertSN, strCertEmail, strCertIssuerDN, lInfoType) {
            var GetCertListCmd = {
                name: "GetCertList",
                p1: strCertType,
                p2: strCertDN,
                p3: strCertSN,
                p4: strCertEmail,
                p5: strCertIssuerDN,
                p6 :lInfoType
            };
            var GetCertListCmdJson = JSON.stringify(GetCertListCmd);
            return _Getretmsg(GetCertListCmdJson);
        },
        GetCertLists: function (strCertType, strCertDN, strCertSN, strCertEmail, strCertIssuerDN, lInfoType) {
            var GetCertListsCmd = {
                name: "GetCertLists",
                p1: strCertType,
                p2: strCertDN,
                p3: strCertSN,
                p4: strCertEmail,
                p5: strCertIssuerDN,
                p6 :lInfoType
            };
            var GetCertListsCmdJson = JSON.stringify(GetCertListsCmd);
            return _Getretmsg(GetCertListsCmdJson);
        },
        SetCertByBase64: function (strBase64) {
            var SetCertByBase64Cmd = {
                name: "SetCertByBase64",
                p1: strBase64
            };
            var SetCertByBase64CmdJson = JSON.stringify(SetCertByBase64Cmd);
            return _Getretcode(SetCertByBase64CmdJson);
        },
        SetCertByBase64Ex: function (strBase64) {
            var SetCertByBase64ExCmd = {
                name: "SetCertByBase64Ex",
                p1: strBase64
            };
            var SetCertByBase64ExCmdJson = JSON.stringify(SetCertByBase64ExCmd);
            return _Getretcode(SetCertByBase64ExCmdJson);
        },
        ChangeCertDN: function (strCertDN, lChangeFlag) {
            var ChangeCertDNCmd = {
                name: "ChangeCertDN",
                p1: strCertDN,
                p2: lChangeFlag
            };
            var ChangeCertDNCmdJson = JSON.stringify(ChangeCertDNCmd);
            return _Getretmsg(ChangeCertDNCmdJson);
        },
        GetVersion: function () {
            return _Getretmsg(GetVersionCmd);
        },
        GetMac: function () {
            return _Getretmsg(GetMacCmd);
        },
        ReStartServer: function () {
            return _Getretmsg(ReStartServerCmd);
        },
        GetData: function () {
            return _Getretmsg(GetDataCmd);
        },
        CheckCertIsExist: function (strCertSN) {
            var CheckCertIsExistCmd = {
                name: "CheckCertIsExist",
                p1: strCertSN
            };
            var CheckCertIsExistCmdJson = JSON.stringify(CheckCertIsExistCmd);
            return _Getretvalue(CheckCertIsExistCmdJson);
        },
        JIT_KeyIsExist: function (flag) {
            var JIT_KeyIsExistCmd = {
                name: "JIT_KeyIsExist",
                p1: flag
            };
            var JIT_KeyIsExistCmdJson = JSON.stringify(JIT_KeyIsExistCmd);
            return _Getretmsg(JIT_KeyIsExistCmdJson);
        },
        GetVCTKIntalledStatus: function () {
            var strobj = _Getretmsg(GetVersionCmd);
            if(strobj=='与服务断开连接')
            {
                return 0;
            }
            else
            {
                return 1;
            }
        },
        AttachSignStr_Batch: function (types, strCertType, strDN, strSN, strEmail, strDNIssuer, strCertBase64, strpincode, strdn, strsrc) {
            var AttachSignStr_BatchCmd = {
                name: "BatchCmd",
                Items: [{
                        name: "SetCertChooseType",
                        p1: types
                    },
                    {
                        name: "SetCert",
                        p1: strCertType,
                        p2: strDN,
                        p3: strSN,
                        p4: strEmail,
                        p5: strDNIssuer,
                        p6: strCertBase64
                    },
                    {
                        name: "AttachSignStr",
                        p1: strdn,
                        p2: strsrc
                    }
                ]
            };
            var AttachSignStr_BatchCmdJson = JSON.stringify(AttachSignStr_BatchCmd); //转换为json字符串
            return _Getretvalue(AttachSignStr_BatchCmdJson);
        },

        AttachSignEx_Batch: function (types, strCertType, strDN, strSN, strEmail, strDNIssuer, strCertBase64, fileNameUseUTF8, strdn, strFileName, strFileNameOut) {
            var AttachSignEx_BatchCmd = {
                name: "BatchCmd",
                Items: [{
                        name: "SetCertChooseType",
                        p1: types
                    },
                    {
                        name: "SetCert",
                        p1: strCertType,
                        p2: strDN,
                        p3: strSN,
                        p4: strEmail,
                        p5: strDNIssuer,
                        p6: strCertBase64
                    },
                    {
                        name: "SetFileNameUseUTF8",
                        p1: fileNameUseUTF8
                    },
                    {
                        name: "AttachSignEx",
                        p1: strdn,
                        p2: strFileName,
                        p3: strFileNameOut
                    }
                ]
            };
            var AttachSignEx_BatchCmdJson = JSON.stringify(AttachSignEx_BatchCmd); //转换为json字符串
            return _Getretvalue(AttachSignEx_BatchCmdJson);
        },

        VerifyAttachedSign_Batch: function (strSignedData) {
            var VerifyAttachedSign_BatchCmd = {
                name: "BatchCmd",
                Items: [{
                    name: "VerifyAttachedSign",
                    p1: strSignedData
                }]
            };
            var VerifyAttachedSign_BatchCmdJson = JSON.stringify(VerifyAttachedSign_BatchCmd);
            return _Getretvalue(VerifyAttachedSign_BatchCmdJson);
        },
        //-------------------------------------------Org Batch Begin--------------------------------------------
        //detach sign
        DetachSignStr_Batch: function (types, strCertType, strDN, strSN, strEmail, strDNIssuer, strCertBase64, strpincode, strdn, strsrc) {
            var DetachSignStr_BatchCmd = {
                name: "BatchCmd",
                Items: [{
                    name: "SetCertChooseType",
                    p1: types
                },
                    {
                        name: "SetCert",
                        p1: strCertType,
                        p2: strDN,
                        p3: strSN,
                        p4: strEmail,
                        p5: strDNIssuer,
                        p6: strCertBase64
                    },
                    {
                        name: "DetachSignStr",
                        p1: strdn,
                        p2: strsrc
                    }
                ]
            };
            var DetachSignStr_BatchCmdJson = JSON.stringify(DetachSignStr_BatchCmd);
            return _Getretvalue(DetachSignStr_BatchCmdJson);
        },
        //detach Vsign
        VertifyDetachSign_Batch: function (strSignedData, strsrc) {
            var VerifyDetachedSignStrCmd = {
                name: "BatchCmd",
                Items: [{
                    name: "VerifyDetachedSignStr",
                    p1: strSignedData,
                    p2: strsrc
                }]
            };
            var VerifyDetachedSignStrCmdJson = JSON.stringify(VerifyDetachedSignStrCmd);
            return _Getretvalue(VerifyDetachedSignStrCmdJson);
        },
        //envelop
        EncryptEnvelopStr_Batch: function (types, strCertType, strDN, strSN, strEmail, strDNIssuer, strCertBase64, strdn, strsrc) {
            var EncryptEnvelopStr_BatchCmd = {
                name: "BatchCmd",
                Items: [{
                    name: "SetCertChooseType",
                    p1: types
                },
                    {
                        name: "SetCert",
                        p1: strCertType,
                        p2: strDN,
                        p3: strSN,
                        p4: strEmail,
                        p5: strDNIssuer,
                        p6: strCertBase64
                    },
                    {
                        name: "EncryptEnvelopStr",
                        p1: strdn,
                        p2: strsrc
                    }
                ]
            };
            var EncryptEnvelopStr_BatchCmdJson = JSON.stringify(EncryptEnvelopStr_BatchCmd);
            return _Getretvalue(EncryptEnvelopStr_BatchCmdJson);
        },
        //envelop(dsCert)
        EncryptEnvelopCertStr_Batch: function (types, strBase64, strdn, strsrc) {
            var EncryptEnvelopCertStr_BatchCmd = {
                name: "BatchCmd",
                Items: [{
                    name: "SetCertChooseType",
                    p1: types
                },
                    {
                        name: "SetCertByBase64",
                        p1: strBase64
                    },
                    {
                        name: "EncryptEnvelopStr",
                        p1: strdn,
                        p2: strsrc
                    }
                ]
            };
            var EncryptEnvelopCertStr_BatchCmdJson = JSON.stringify(EncryptEnvelopCertStr_BatchCmd);
            return _Getretvalue(EncryptEnvelopCertStr_BatchCmdJson);
        },
        //decryptEnvelop
        DecryptEnvelopStr_Batch: function (strEnvelop) {
            var DecryptEnvelopStr_BatchCmd = {
                name: "BatchCmd",
                Items: [{
                    name: "DecryptEnvelop",
                    p1: strEnvelop
                }]
            };
            var DecryptEnvelopStr_BatchCmdJson = JSON.stringify(DecryptEnvelopStr_BatchCmd);
            return _Getretvalue(DecryptEnvelopStr_BatchCmdJson);
        },
        //hashDigest
        HashDigest_Batch: function (strSrcData) {
            var HashDigest_BatchCmd = {
                name: "BatchCmd",
                Items: [{
                    name: "Digest",
                    p1: strSrcData
                }]
            };
            var HashDigest_BatchCmdJson = JSON.stringify(HashDigest_BatchCmd);
            return _Getretmsg(HashDigest_BatchCmdJson);
        },
        VerifyPinCode_Batch: function (types, strCertType, strDN, strSN, strEmail, strDNIssuer, strCertBase64, strPinCode, strNewPinCode) {
            var VerifyPinCode_BatchCmd = {
                name: "BatchCmd",
                Items: [{
                    name: "SetCertChooseType",
                    p1: types
                },
                    {
                        name: "SetCert",
                        p1: strCertType,
                        p2: strDN,
                        p3: strSN,
                        p4: strEmail,
                        p5: strDNIssuer,
                        p6: strCertBase64
                    },
                    {
                        name: "VerifyPinCode",
                        p1: strPinCode,
                        p2: strNewPinCode
                    }
                ]
            };
            var VerifyPinCode_BatchCmdJson = JSON.stringify(VerifyPinCode_BatchCmd);
            return _Getretcode(VerifyPinCode_BatchCmdJson);
        },
        MOF_DetachSignStr_Batch: function (moftypes, types, strCertType, strDN, strSN, strEmail, strDNIssuer, strCertBase64, strdn, iscert, strsrc, strserverinfo) {
            var MOF_DetachSignStr_BatchCmd = {
                name: "BatchCmd",
                Items: [{
                    name: "MOF_SetFlag",
                    p1: moftypes
                    },
                    {
                        name: "SetCertChooseType",
                        p1: types
                    },
                    {
                        name: "SetCert",
                        p1: strCertType,
                        p2: strDN,
                        p3: strSN,
                        p4: strEmail,
                        p5: strDNIssuer,
                        p6: strCertBase64
                    },
                    {
                        name: "MOF_DetachSignStr",
                        p1: strdn,
                        p2: iscert,
                        p3: strsrc,
                        p4: strserverinfo
                    }
                ]
            };
            var MOF_DetachSignStr_BatchCmdJson = JSON.stringify(MOF_DetachSignStr_BatchCmd);
            return _Getretvalue(MOF_DetachSignStr_BatchCmdJson);
        },
        MOF_VerifyDetachedSignStr_Batch: function (InitParam2,moftypes, strSignedData, strsrc ) {
            var MOFVerifyDetachedSignStr_BatchCmd = {
                name: "BatchCmd",
                Items: [
                    {
                        name: "RegisterParamMore",
                        p1: InitParam2
                    },
                    {
                        name: "MOF_SetFlag",
                        p1: moftypes
                    },
                    {
                        name: "MOF_VerifyDetachedSignStr",
                        p1: strSignedData,
                        p2: strsrc
                    }
                ]
            };
            var MOFVerifyDetachedSignStr_BatchCmdJson = JSON.stringify(MOFVerifyDetachedSignStr_BatchCmd);
            return _Getretvalue(MOFVerifyDetachedSignStr_BatchCmdJson);
        },
        MOF_EncryptEnvelopStr_Batch: function (moftypes, types, strCertType, strDN, strSN, strEmail, strDNIssuer, strCertBase64, strdn, strsrc, strserverinfo) {
            var MOFEncryptEnvelopStr_BatchCmd = {
                name: "BatchCmd",
                Items: [{
                    name: "MOF_SetFlag",
                    p1: moftypes
                },
                    {
                        name: "SetCertChooseType",
                        p1: types
                    },
                    {
                        name: "SetCert",
                        p1: strCertType,
                        p2: strDN,
                        p3: strSN,
                        p4: strEmail,
                        p5: strDNIssuer,
                        p6: strCertBase64
                    },
                    {
                        name: "MOF_EncryptEnvelopStr",
                        p1: strdn,
                        p2: strsrc,
                        p3: strserverinfo
                    }
                ]
            };
            var MOFEncryptEnvelopStr_BatchCmdJson = JSON.stringify(MOFEncryptEnvelopStr_BatchCmd);
            return _Getretvalue(MOFEncryptEnvelopStr_BatchCmdJson);
        },
        MOF_DecryptEnvelopStr_Batch: function (moftypes, strEnvelop) {
            var MOFDecryptEnvelopStr_BatchCmd = {
                name: "BatchCmd",
                Items: [{
                        name: "MOF_SetFlag",
                        p1: moftypes
                    },
                    {
                        name: "MOF_DecryptEnvelop",
                        p1: strEnvelop
                    }
                ]
            };
            var MOFDecryptEnvelopStr_BatchCmdJson = JSON.stringify(MOFDecryptEnvelopStr_BatchCmd);
            return _Getretvalue(MOFDecryptEnvelopStr_BatchCmdJson);
        },
        MOF_EncryptEnvelopMultiCertStr2_Batch: function (moftypes, strBase64_1, strBase64_2, types, strdn, strsrc, strserverinfo) {
            var MOFEncryptEnvelopMultiCertStr2_BatchCmd = {
                name: "BatchCmd",
                Items: [{
                        name: "MOF_SetFlag",
                        p1: moftypes
                    },
                    {
                        name: "SetCertByBase64Ex",
                        p1: strBase64_1
                    },
                    {
                        name: "SetCertByBase64Ex",
                        p1: strBase64_2
                    },
                    {
                        name: "SetCertChooseType",
                        p1: types
                    },
                    {
                        name: "MOF_EncryptEnvelopStr",
                        p1: strdn,
                        p2: strsrc,
                        p3: strserverinfo
                    }
                ]
            };
            var MOFEncryptEnvelopMultiCertStr2_BatchCmdJson = JSON.stringify(MOFEncryptEnvelopMultiCertStr2_BatchCmd);
            return _Getretvalue(MOFEncryptEnvelopMultiCertStr2_BatchCmdJson);
        },
        MOF_EncryptEnvelopMultiCertStr1_Batch: function (moftypes, strBase64, types, strdn, strsrc, strserverinfo) {
            var MOFEncryptEnvelopMultiCertStr1_BatchCmd = {
                name: "BatchCmd",
                Items: [{
                    name: "MOF_SetFlag",
                    p1: moftypes
                },
                    {
                        name: "SetCertByBase64Ex",
                        p1: strBase64_1
                    },
                    {
                        name: "SetCertChooseType",
                        p1: types
                    },
                    {
                        name: "MOF_EncryptEnvelopStr",
                        p1: strdn,
                        p2: strsrc,
                        p3: strserverinfo
                    }
                ]
            };
            var MOFEncryptEnvelopMultiCertStr1_BatchCmdJson = JSON.stringify(MOFEncryptEnvelopMultiCertStr1_BatchCmd);
            return _Getretvalue(MOFEncryptEnvelopMultiCertStr1_BatchCmdJson);
        },
        P1SignStr_Batch: function (types, strCertType, strDN, strSN, strEmail, strDNIssuer, strCertBase64, strdn, strsrc) {
            var P1SignStr_BatchCmd = {
                name: "BatchCmd",
                Items: [
                    {
                        name: "SetCertChooseType",
                        p1: types
                    },
                    {
                        name: "SetCert",
                        p1: strCertType,
                        p2: strDN,
                        p3: strSN,
                        p4: strEmail,
                        p5: strDNIssuer,
                        p6: strCertBase64
                    },
                    {
                        name: "P1SignStr",
                        p1: strdn,
                        p2: strsrc
                    }
                ]
            };
            var P1SignStr_BatchCmdJson = JSON.stringify(P1SignStr_BatchCmd);
            return _Getretvalue(P1SignStr_BatchCmdJson);
        },
        CreateSignedEnvelopStr_Batch: function (types,
            SCstrCertType, SCstrDN, SCstrSN, SCstrEmail, SCstrDNIssuer, SCstrCertBase64,
            ECstrCertType, ECstrDN, ECstrSN, ECstrEmail, ECstrDNIssuer, ECstrCertBase64,
            strSignCertDN, strEncCertDN, strSrc) {
            var CreateSignedEnvelopStr_BatchCmd = {
                name: "BatchCmd",
                Items: [
                    {
                        name: "SetCertChooseType",
                        p1: types
                    },
                    {
                        name: "SetCert",
                        p1: SCstrCertType,
                        p2: SCstrDN,
                        p3: SCstrSN,
                        p4: SCstrEmail,
                        p5: SCstrDNIssuer,
                        p6: SCstrCertBase64
                    },
                    {
                        name: "SetCert",
                        p1: ECstrCertType,
                        p2: ECstrDN,
                        p3: ECstrSN,
                        p4: ECstrEmail,
                        p5: ECstrDNIssuer,
                        p6: ECstrCertBase64
                    },
                    {
                        name: "CreateSignedEnvelopStr",
                        p1: strSignCertDN,
                        p2: strEncCertDN,
                        p3: strSrc
                    }
                ]
            };
            var CreateSignedEnvelopStr_BatchCmdJson = JSON.stringify(CreateSignedEnvelopStr_BatchCmd);
            return _Getretmsg(CreateSignedEnvelopStr_BatchCmdJson);
        },
        CreateSignedEnvelopCertStr_Batch: function (types,
            SCstrCertType, SCstrDN, SCstrSN, SCstrEmail, SCstrDNIssuer, SCstrCertBase64,
            strBase64, strSignCertDN, strEncCertDN, strSrc) {
            var CreateSignedEnvelopCertStr_BatchCmd = {
                name: "BatchCmd",
                Items: [
                    {
                        name: "SetCertChooseType",
                        p1: types
                    },
                    {
                        name: "SetCert",
                        p1: SCstrCertType,
                        p2: SCstrDN,
                        p3: SCstrSN,
                        p4: SCstrEmail,
                        p5: SCstrDNIssuer,
                        p6: SCstrCertBase64
                    },
                    {
                        name: "SetCertByBase64",
                        p1: strBase64
                    },
                    {
                        name: "CreateSignedEnvelopStr",
                        p1: strSignCertDN,
                        p2: strEncCertDN,
                        p3:strSrc
                    }
                ]
            };
            var CreateSignedEnvelopCertStr_BatchCmdJson = JSON.stringify(CreateSignedEnvelopCertStr_BatchCmd);
            return _Getretmsg(CreateSignedEnvelopCertStr_BatchCmdJson);
        },
        SymmetricEncrypt_Batch: function (strHashAlg, strEncAlg, strSymmetricKey, strSrcData, isPad) {
            var SymmetricEncrypt_BatchCmd = {
                name: "BatchCmd",
                Items: [
                    {
                        name: "SetAlgorithm",
                        p1: strHashAlg,
                        p2: strEncAlg
                    },
                    {
                        name: "SymmetricEncrypt",
                        p1: strSymmetricKey,
                        p2: strSrcData,
                        p3: isPad
                    }
                ]
            };
            var SymmetricEncrypt_BatchCmdJson = JSON.stringify(SymmetricEncrypt_BatchCmd);
            return _Getretmsg(SymmetricEncrypt_BatchCmdJson);
        },
        SymmetricDecrypt_Batch: function (strHashAlg, strEncAlg, strSymmetricKey, strEncryptData, isPad) {
            var SymmetricDecrypt_BatchCmd = {
                name: "BatchCmd",
                Items: [
                    {
                        name: "SetAlgorithm",
                        p1: strHashAlg,
                        p2: strEncAlg
                    },
                    {
                        name: "SymmetricDecrypt",
                        p1: strSymmetricKey,
                        p2: strEncryptData,
                        p3: isPad
                    }
                ]
            };
            var SymmetricDecrypt_BatchCmdJson = JSON.stringify(SymmetricDecrypt_BatchCmd);
            return _Getretmsg(SymmetricDecrypt_BatchCmdJson);
        },
        SetCertEx_Batch: function (types, strCertStoreType, strCertType, strDN, strSN, strEmail, strDNIssuer, strCertBase64) {
            var SetCertEx_BatchCmd = {
                name: "BatchCmd",
                Items: [
                    {
                        name: "SetCertChooseType",
                        p1: types
                    },
                    {
                        name: "SetCertEx",
                        p1: strCertStoreType,
                        p2: strCertType,
                        p3: strDN,
                        p4: strSN,
                        p5: strEmail,
                        p6: strDNIssuer,
                        p7: strCertBase64
                    }
                ]
            };
            var SetCertEx_BatchCmdJson = JSON.stringify(SetCertEx_BatchCmd);
            return _Getretmsg(SetCertEx_BatchCmdJson);
        },
        SetCert2_Batch: function (types, strCertType, strDN, strSN, strEmail, strDNIssuer, strCertBase64, strCertNameType) {
            var SetCert2_BatchCmd = {
                name: "BatchCmd",
                Items: [
                    {
                        name: "SetCertChooseType",
                        p1: types
                    },
                    {
                        name: "SetCert2",
                        p1: strCertType,
                        p2: strDN,
                        p3: strSN,
                        p4: strEmail,
                        p5: strDNIssuer,
                        p6: strCertBase64,
                        p7: strCertNameType
                    }
                ]
            };
            var SetCert2_BatchCmdJson = JSON.stringify(SetCert2_BatchCmd);
            return _Getretcode(SetCert2_BatchCmdJson);
        },
        GetCertLists_Batch: function (strCertType, strCertDN, strCertSN, strCertEmail, strCertIssuerDN, lInfoType) {
            var GetCertLists_BatchCmd = {
                name: "BatchCmd",
                Items: [{
                        name: "GetCertLists",
                        p1: strCertType,
                        p2: strCertDN,
                        p3: strCertSN,
                        p4: strCertEmail,
                        p5: strCertIssuerDN,
                        p6: lInfoType
                    }
                ]
            };
            var GetCertLists_BatchCmdJson = JSON.stringify(GetCertLists_BatchCmd);
            return _Getretmsg(GetCertLists_BatchCmdJson);
        },
        //-------------------------------------------Org Batch End----------------------------------------------
        /******file batch start*****/
        //Attach Sign File
        AttachSignEx_file_Batch: function (strinitParam, types, strCertType, strDN, strSN, strEmail, strDNIssuer, strCertBase64, fileNameUseUTF8, strdn, strFileName, strFileNameOut) {
            var strFileName = strFileName.replace(/\\/g, '\\\\');
            var strFileNameOut = strFileNameOut.replace(/\\/g, '\\\\');
            var AttachSignEx_BatchCmd = {
                name: "BatchCmd",
                Items: [{
                        name: "RegisterParam",
                        p1: strinitParam
                     },
                    {
                        name: "SetCertChooseType",
                        p1: types
                    },
                    {
                        name: "SetCert",
                        p1: strCertType,
                        p2: strDN,
                        p3: strSN,
                        p4: strEmail,
                        p5: strDNIssuer,
                        p6: strCertBase64
                    },
                    {
                        name: "AttachSignEx",
                        p1: strdn,
                        p2: strFileName,
                        p3:strFileNameOut
                    }
                ]
            };
            var AttachSignEx_BatchCmdJson = JSON.stringify(AttachSignEx_BatchCmd);
            return _Getretvalue(AttachSignEx_BatchCmdJson);
        },


        //Attach Sign Big File
        JITAttachFromFile_file_BigData_Batch: function (strinitParam, types, strCertType, strDN, strSN, strEmail, strDNIssuer, strCertBase64, fileNameUseUTF8, strdn, strFileName, strFileNameOut) {
            //    var strFileName = strFileName.replace(/\\/g,'\\\\');
            //    var strFileNameOut = strFileNameOut.replace(/\\/g,'\\\\');
            var JITAttachFromFile_BigData_BatchCmd = {
                name: "BatchCmd",
                Items: [{
                        name: "RegisterParam",
                        p1: strinitParam
                    },
                    {
                        name: "SetCertChooseType",
                        p1: types
                    },
                    {
                        name: "SetCert",
                        p1: strCertType,
                        p2: strDN,
                        p3: strSN,
                        p4: strEmail,
                        p5: strDNIssuer,
                        p6: strCertBase64
                    },
                    {
                        name: "JITAttachFromFile_BigData",
                        p1: strdn,
                        p2: strFileName,
                        p3: strFileNameOut
                    }
                ]
            };
            var JITAttachFromFile_BigData_BatchCmdJson = JSON.stringify(JITAttachFromFile_BigData_BatchCmd); //转换为json字符串
            return _Getretvalue(JITAttachFromFile_BigData_BatchCmdJson);
        },

        //Detach Sign File
        DetachSignEx_file_Batch: function (strinitParam, types, strCertType, strDN, strSN, strEmail, strDNIssuer, strCertBase64, fileNameUseUTF8, strdn, strFileName, strFileNameOut) {
            var strFileName = strFileName.replace(/\\/g, '\\\\');
            var strFileNameOut = strFileNameOut.replace(/\\/g, '\\\\');
            var DetachSignEx_BatchCmd = {
                name: "BatchCmd",
                Items: [{
                    name: "RegisterParam",
                    p1: strinitParam
                },
                    {
                        name: "SetCertChooseType",
                        p1: types
                    },
                    {
                        name: "SetCert",
                        p1: strCertType,
                        p2: strDN,
                        p3: strSN,
                        p4: strEmail,
                        p5: strDNIssuer,
                        p6: strCertBase64
                    },
                    {
                        name: "DetachSignEx",
                        p1: strdn,
                        p2: strFileName,
                        p3: strFileNameOut
                    }
                ]
            };
            var DetachSignEx_BatchCmdJson = JSON.stringify(DetachSignEx_BatchCmd);
            return _Getretvalue(DetachSignEx_BatchCmdJson);
        },

        //Detach Sign File val
        JITDetachFromFile_BigData_Val_file_Batch: function (strinitParam, types, strCertType, strDN, strSN, strEmail, strDNIssuer, strCertBase64, fileNameUseUTF8, strdn, strFileName, strFileNameOut) {
            var strFileName = strFileName.replace(/\\/g, '\\\\');
            var strFileNameOut = strFileNameOut.replace(/\\/g, '\\\\');
            var JITDetachFromFile_BigData_Val_BatchCmd = {
                name: "BatchCmd",
                Items: [{
                    name: "RegisterParam",
                    p1: strinitParam
                },
                    {
                        name: "SetCertChooseType",
                        p1: types
                    },
                    {
                        name: "SetCert",
                        p1: strCertType,
                        p2: strDN,
                        p3: strSN,
                        p4: strEmail,
                        p5: strDNIssuer,
                        p6: strCertBase64
                    },
                    {
                        name: "JITDetachFromFile_BigData_Val",
                        p1: strdn,
                        p2: strFileName,
                        p3: strFileNameOut
                    }
                ]
            };
            var JITDetachFromFile_BigData_Val_BatchCmdJson = JSON.stringify(JITDetachFromFile_BigData_Val_BatchCmd);
            return _Getretvalue(JITDetachFromFile_BigData_Val_BatchCmdJson);
        },

        //Detach Sign Big File
        JITDetachFromFile_BigData_file_Batch: function (strinitParam, types, strCertType, strDN, strSN, strEmail, strDNIssuer, strCertBase64, fileNameUseUTF8, strdn, strFileName, strFileNameOut) {
            var strFileName = strFileName.replace(/\\/g, '\\\\');
            var strFileNameOut = strFileNameOut.replace(/\\/g, '\\\\');
            var JITDetachFromFile_BigData_BatchCmd = {
                name: "BatchCmd",
                Items: [{
                    name: "RegisterParam",
                    p1: strinitParam
                },
                    {
                        name: "SetCertChooseType",
                        p1: types
                    },
                    {
                        name: "SetCert",
                        p1: strCertType,
                        p2: strDN,
                        p3: strSN,
                        p4: strEmail,
                        p5: strDNIssuer,
                        p6: strCertBase64
                    },
                    {
                        name: "JITDetachFromFile_BigData",
                        p1: strdn,
                        p2: strFileName,
                        p3: strFileNameOut
                    }
                ]
            };
            var JITDetachFromFile_BigData_BatchCmdJson = JSON.stringify(JITDetachFromFile_BigData_BatchCmd);
            return _Getretvalue(JITDetachFromFile_BigData_BatchCmdJson);
        },

        //Verify Attach Sign File
        VerifyAttachedSignEx_file_Batch: function (strinitParam, fileNameUseUTF8, resultFileName, dSignSavefile) {
            var resultFileName = resultFileName.replace(/\\/g, '\\\\');
            var dSignSavefile = dSignSavefile.replace(/\\/g, '\\\\');
            var VerifyAttachedSignEx_BatchCmd = {
                name: "BatchCmd",
                Items: [{
                    name: "RegisterParam",
                    p1: strinitParam
                    },
                    {
                        name: "SetFileNameUseUTF8",
                        p1: fileNameUseUTF8
                    },
                    {
                        name: "VerifyAttachedSignEx",
                        p1: resultFileName
                    },
                    {
                        name: "GetFile",
                        p1: dSignSavefile
                    }
                ]
            };
            var VerifyAttachedSignEx_BatchCmdJson = JSON.stringify(VerifyAttachedSignEx_BatchCmd);
            return _Getretvalue(VerifyAttachedSignEx_BatchCmdJson);
        },

        //Verify Attach Sign
        VerifyAttachedSign_file_Batch: function (strinitParam, fileNameUseUTF8, strSignedData, dSignSavefile) {
            var dSignSavefile = dSignSavefile.replace(/\\/g, '\\\\');
            var VerifyAttachedSign_BatchCmd = {
                name: "BatchCmd",
                Items: [{
                    name: "RegisterParam",
                    p1: strinitParam
                    },
                    {
                        name: "SetFileNameUseUTF8",
                        p1: fileNameUseUTF8
                    },
                    {
                        name: "VerifyAttachedSign",
                        p1: strSignedData
                    },
                    {
                        name: "GetFile",
                        p1: dSignSavefile
                    }
                ]
            };
            var VerifyAttachedSign_BatchCmdJson = JSON.stringify(VerifyAttachedSign_BatchCmd);
            return _Getretvalue(VerifyAttachedSign_BatchCmdJson);
        },

        //Verify Attach Sign Big File
        JITVerifyAttachFromFile_BigData_file_Batch: function (strinitParam, fileNameUseUTF8, resultFileName, dSignSavefile) {
            var resultFileName = resultFileName.replace(/\\/g, '\\\\');
            var dSignSavefile = dSignSavefile.replace(/\\/g, '\\\\');
            var JITVerifyAttachFromFile_BigData_BatchCmd = {
                name: "BatchCmd",
                Items: [{
                    name: "RegisterParam",
                    p1: strinitParam
                    },
                    {
                        name: "SetFileNameUseUTF8",
                        p1: fileNameUseUTF8
                    },
                    {
                        name: "JITVerifyAttachFromFile_BigData",
                        p1: resultFileName,
                        p2: dSignSavefile
                    }
                ]
            };
            var JITVerifyAttachFromFile_BigData_BatchCmdJson = JSON.stringify(JITVerifyAttachFromFile_BigData_BatchCmd);
            return _Getretvalue(JITVerifyAttachFromFile_BigData_BatchCmdJson);
        },

        //Verify Detach Sign File
        VerifyDetachedSignEx_file_Batch: function (strinitParam, fileNameUseUTF8, strSignedResultData, resultFileName, dSignSourceFile) {
            var resultFileName = resultFileName.replace(/\\/g, '\\\\');
            var dSignSourceFile = dSignSourceFile.replace(/\\/g, '\\\\');
            var VerifyDetachedSignEx_BatchCmd = {
                name: "BatchCmd",
                Items: [{
                    name: "RegisterParam",
                    p1: strinitParam
                    },
                    {
                        name: "SetFileNameUseUTF8",
                        p1: fileNameUseUTF8
                    },
                    {
                        name: "VerifyDetachedSignEx",
                        p1: strSignedResultData,
                        p2: resultFileName,
                        P3: dSignSourceFile
                    }
                ]
            };
            var VerifyDetachedSignEx_BatchCmdJson = JSON.stringify(VerifyDetachedSignEx_BatchCmd);
            return _Getretvalue(VerifyDetachedSignEx_BatchCmdJson);
        },


        //Verify Detach Sign Big File
        JITVerifyDetachFromFile_BigData_file_Batch: function (strinitParam, fileNameUseUTF8, resultFileName, dSignSavefile) {
            var resultFileName = resultFileName.replace(/\\/g, '\\\\');
            var dSignSavefile = dSignSavefile.replace(/\\/g, '\\\\');
            var JITVerifyDetachFromFile_BigData_BatchCmd = {
                name: "BatchCmd",
                Items: [{
                    name: "RegisterParam",
                    p1: strinitParam
                    },
                    {
                        name: "SetFileNameUseUTF8",
                        p1: fileNameUseUTF8
                    },
                    {
                        name: "JITVerifyDetachFromFile_BigData",
                        p1: resultFileName,
                        p2: dSignSavefile
                    }
                ]
            };
            var JITVerifyDetachFromFile_BigData_BatchCmdJson = JSON.stringify(JITVerifyDetachFromFile_BigData_BatchCmd);
            return _Getretvalue(JITVerifyDetachFromFile_BigData_BatchCmdJson);
        },

        //EncryptEnvelopEx File
        EncryptEnvelopEx_file_Batch: function (strinitParam, types, strCertType, strDN, strSN, strEmail, strDNIssuer, strCertBase64, fileNameUseUTF8, strdn, strFileName, strFileNameOut) {
            var strFileName = strFileName.replace(/\\/g, '\\\\');
            var strFileNameOut = strFileNameOut.replace(/\\/g, '\\\\');
            var EncryptEnvelopEx_BatchCmd = {
                name: "BatchCmd",
                Items: [{
                    name: "RegisterParam",
                    p1: strinitParam
                },
                    {
                        name: "SetCertChooseType",
                        p1: types
                    },
                    {
                        name: "SetCert",
                        p1: strCertType,
                        p2: strDN,
                        p3: strSN,
                        p4: strEmail,
                        p5: strDNIssuer,
                        p6: strCertBase64
                    },
                    {
                        name: "SetFileNameUseUTF8",
                        p1: fileNameUseUTF8
                    },
                    {
                        name: "EncryptEnvelopEx",
                        p1: strdn,
                        p2: strFileName,
                        p3: strFileNameOut
                    }
                ]
            };
            var EncryptEnvelopEx_BatchCmdJson = JSON.stringify(EncryptEnvelopEx_BatchCmd);
            return _Getretvalue(EncryptEnvelopEx_BatchCmdJson);
        },


        //Envelope Big File
        JITCreateEnvelopeFromFile_BigData_file_Batch: function (strinitParam, types, strCertType, strDN, strSN, strEmail, strDNIssuer, strCertBase64, fileNameUseUTF8, strdn, strFileName, strFileNameOut) {
            var strFileName = strFileName.replace(/\\/g, '\\\\');
            var strFileNameOut = strFileNameOut.replace(/\\/g, '\\\\');
            var JITCreateEnvelopeFromFile_BigData_BatchCmd = {
                name: "BatchCmd",
                Items: [{
                        name: "RegisterParam",
                        p1: strinitParam
                    },
                    {
                        name: "SetCertChooseType",
                        p1: types
                    },
                    {
                        name: "SetCert",
                        p1: strCertType,
                        p2: strDN,
                        p3: strSN,
                        p4: strEmail,
                        p5: strDNIssuer,
                        p6: strCertBase64
                    },
                    {
                        name: "SetFileNameUseUTF8",
                        p1: fileNameUseUTF8
                    },
                    {
                        name: "JITCreateEnvelopeFromFile_BigData",
                        p1: strdn,
                        p2: strFileName,
                        p3: strFileNameOut
                    }
                ]
            };
            var JITCreateEnvelopeFromFile_BigData_BatchCmdJson = JSON.stringify(JITCreateEnvelopeFromFile_BigData_BatchCmd);
            return _Getretvalue(JITCreateEnvelopeFromFile_BigData_BatchCmdJson);
        },

        //Decrypt Envelop content
        DecryptEnvelop_file_Batch: function (strinitParam, fileNameUseUTF8, strEnvelopData, dSignSavefile) {
            var dSignSavefile = dSignSavefile.replace(/\\/g, '\\\\');
            var DecryptEnvelop_BatchCmd = {
                name: "BatchCmd",
                Items: [{
                    name: "RegisterParam",
                    p1: strinitParam
                    },
                    {
                        name: "SetFileNameUseUTF8",
                        p1: fileNameUseUTF8
                    },
                    {
                        name: "DecryptEnvelop",
                        p1: strEnvelopData
                    },
                    {
                        name: "GetFile",
                        p1: dSignSavefile
                    }
                ]
            };
            var DecryptEnvelop_BatchCmdJson = JSON.stringify(DecryptEnvelop_BatchCmd);
            return _Getretvalue(DecryptEnvelop_BatchCmdJson);
        },


        //Decrypt Envelop File
        DecryptEnvelopEx_file_Batch: function (strinitParam, fileNameUseUTF8, resultFileName, dSignSavefile) {
            var resultFileName = resultFileName.replace(/\\/g, '\\\\');
            var dSignSavefile = dSignSavefile.replace(/\\/g, '\\\\');
            var DecryptEnvelopEx_BatchCmd = {
                name: "BatchCmd",
                Items: [{
                    name: "RegisterParam",
                    p1: strinitParam
                },
                    {
                        name: "SetFileNameUseUTF8",
                        p1: fileNameUseUTF8
                    },
                    {
                        name: "DecryptEnvelopEx",
                        p1: resultFileName
                    },
                    {
                        name: "GetFile",
                        p1: dSignSavefile
                    }
                ]
            };
            var DecryptEnvelopEx_BatchCmdJson = JSON.stringify(DecryptEnvelopEx_BatchCmd);
            return _Getretvalue(DecryptEnvelopEx_BatchCmdJson);
        },

        //Decrypt Envelop Big File
        JITDecryptEnvelopeFromFile_BigData_file_Batch: function (strinitParam, fileNameUseUTF8, strEnvelopData, dEnvelopSavefile) {
            var strEnvelopData = strEnvelopData.replace(/\\/g, '\\\\');
            var dEnvelopSavefile = dEnvelopSavefile.replace(/\\/g, '\\\\');
            var JITDecryptEnvelopeFromFile_BigData_BatchCmd = {
                name: "BatchCmd",
                Items: [{
                    name: "RegisterParam",
                    p1: strinitParam
                },
                    {
                        name: "SetFileNameUseUTF8",
                        p1: fileNameUseUTF8
                    },
                    {
                        name: "JITDecryptEnvelopeFromFile_BigData",
                        p1: strEnvelopData,
                        P2: dEnvelopSavefile
                    }
                ]
            };
            var JITDecryptEnvelopeFromFile_BigData_BatchCmdJson = JSON.stringify(JITDecryptEnvelopeFromFile_BigData_BatchCmd);
            return _Getretvalue(JITDecryptEnvelopeFromFile_BigData_BatchCmdJson);
        },

        //Digest File
        DigestFromFile_file_Batch: function (strinitParam, strfilename) {
            var strfilename = strfilename.replace(/\\/g, '\\\\');
            var DigestFromFile_BatchCmd = {
                name: "BatchCmd",
                Items: [{
                    name: "RegisterParam",
                    p1: strinitParam
                    },
                    {
                        name: "DigestFromFile",
                        p1: strfilename
                    }
                ]
            };
            var DigestFromFile_BatchCmdJson = JSON.stringify(DigestFromFile_BatchCmd);
            return _Getretvalue(DigestFromFile_BatchCmdJson);
        },


        //Signed EnvelopEx File
        CreateSignedEnvelopEx_file_Batch: function (strinitParam, types, strSignCertType, strSignDN, strSignSN, strSignEmail, strSignDNIssuer, strSignCertBase64, strEnvCertType, strEnvDN, strEnvSN, strEnvEmail, strEnvDNIssuer, strEnvCertBase64, fileNameUseUTF8, strSignCertDN, strEncCertDN, strFileName, strFileNameOut) {
            var strFileName = strFileName.replace(/\\/g, '\\\\');
            var strFileNameOut = strFileNameOut.replace(/\\/g, '\\\\');
            var CreateSignedEnvelopEx_BatchCmd = {
                name: "BatchCmd",
                Items: [{
                        name: "RegisterParam",
                        p1: strinitParam
                    },
                    {
                        name: "SetCertChooseType",
                        p1: types
                    },
                    {
                        name: "SetCert",
                        p1: strSignCertType,
                        p2: strSignDN,
                        p3: strSignSN,
                        p4: strSignEmail,
                        p5: strSignDNIssuer,
                        p6: strSignCertBase64
                    },
                    {
                        name: "SetCert",
                        p1: strEnvCertType,
                        p2: strEnvDN,
                        p3: strEnvSN,
                        p4: strEnvEmail,
                        p5: strEnvDNIssuer,
                        p6: strEnvCertBase64
                    },
                    {
                        name: "SetFileNameUseUTF8",
                        p1: fileNameUseUTF8
                    },
                    {
                        name: "CreateSignedEnvelopEx",
                        p1: strSignCertDN,
                        p2: strEncCertDN,
                        p3: strFileName,
                        P4: strFileNameOut
                    }
                ]
            };
            var CreateSignedEnvelopEx_BatchCmdJson = JSON.stringify(CreateSignedEnvelopEx_BatchCmd);
            return _Getretvalue(CreateSignedEnvelopEx_BatchCmdJson);
        },

        // VerifySignedEnvelopEx File

        VerifySignedEnvelopEx_file_Batch: function (strinitParam, fileNameUseUTF8, strFileName, strFileNameOut) {
            var strFileName = strFileName.replace(/\\/g, '\\\\');
            var strFileNameOut = strFileNameOut.replace(/\\/g, '\\\\');
            var VerifySignedEnvelopEx_BatchCmd = {
                name: "BatchCmd",
                Items: [{
                        name: "RegisterParam",
                        p1: strinitParam
                    },
                    {
                        name: "SetFileNameUseUTF8",
                        p1: fileNameUseUTF8
                    },
                    {
                        name: "VerifySignedEnvelopEx",
                        p1: strFileName
                    },
                    {
                        name: "GetFile",
                        p1: strFileNameOut
                    }
                ]
            };
            var VerifySignedEnvelopEx_BatchCmdJson = JSON.stringify(VerifySignedEnvelopEx_BatchCmd);
            return _Getretvalue(VerifySignedEnvelopEx_BatchCmdJson);
        },

        // VerifySignedEnvelopEx File
        VerifySignedEnvelop_file_Batch: function (strinitParam, fileNameUseUTF8, strSignEnvelopData, strFileNameOut) {
            var strFileNameOut = strFileNameOut.replace(/\\/g, '\\\\');
            var VerifySignedEnvelop_BatchCmd = {
                name: "BatchCmd",
                Items: [{
                        name: "RegisterParam",
                        p1: strinitParam
                    },
                    {
                        name: "SetFileNameUseUTF8",
                        p1: fileNameUseUTF8
                    },
                    {
                        name: "VerifySignedEnvelop",
                        p1: strSignEnvelopData
                    },
                    {
                        name: "GetFile",
                        p1: strFileNameOut
                    }
                ]
            };
            var VerifySignedEnvelop_BatchCmdJson = JSON.stringify(VerifySignedEnvelop_BatchCmd);
            return _Getretvalue(VerifySignedEnvelop_BatchCmdJson);
        },

        //JITSignEnvelopeFromFile_BigData_Batch
        JITSignEnvelopeFromFile_BigData_file_Batch: function (strinitParam, types, fileNameUseUTF8, strSignCertType, strSignDN, strSignSN, strSignEmail, strSignDNIssuer, strSignCertBase64, strEnvCertType, strEnvDN, strEnvSN, strEnvEmail, strEnvDNIssuer, strEnvCertBase64, strSignCertDN, strEncCertDN, strFileName, strFileNameOut) {
            var strFileName = strFileName.replace(/\\/g, '\\\\');
            var strFileNameOut = strFileNameOut.replace(/\\/g, '\\\\');
            var JITSignEnvelopeFromFile_BigData_BatchCmd = {
                name: "BatchCmd",
                    Items: [{
                        name: "RegisterParam",
                        p1: strinitParam
                    },
                    {
                        name: "SetCertChooseType",
                        p1: types
                    },
                    {
                        name: "SetFileNameUseUTF8",
                        p1: fileNameUseUTF8
                    },
                    {
                        name: "SetCert",
                        p1: strSignCertType,
                        p2: strSignDN,
                        p3: strSignSN,
                        p4: strSignEmail,
                        p5: strSignDNIssuer,
                        p6: strSignCertBase64
                    },
                    {
                        name: "SetCert",
                        p1: strEnvCertType,
                        p2: strEnvDN,
                        p3: strEnvSN,
                        p4: strEnvEmail,
                        p5: strEnvDNIssuer,
                        p6: strEnvCertBase64
                    },
                    {
                        name: "JITSignEnvelopeFromFile_BigData",
                        p1: strSignCertDN,
                        p2: strEncCertDN,
                        p3: strFileName,
                        P4: strFileNameOut
                    }
                ]
            };
            var JITSignEnvelopeFromFile_BigData_BatchCmdJson = JSON.stringify(JITSignEnvelopeFromFile_BigData_BatchCmd);
            return _Getretvalue(JITSignEnvelopeFromFile_BigData_BatchCmdJson);
        },


        //JITDecryptSignEnvelopeFromFile_BigData
        JITDecryptSignEnvelopeFromFile_BigData_file_Batch: function (strinitParam, fileNameUseUTF8, strFileName, strFileNameOut) {
            var strFileName = strFileName.replace(/\\/g, '\\\\');
            var strFileNameOut = strFileNameOut.replace(/\\/g, '\\\\');
            var JITDecryptSignEnvelopeFromFile_BigData_BatchCmd = {
                name: "BatchCmd",
                Items: [{
                        name: "RegisterParam",
                        p1: strinitParam
                    },
                    {
                        name: "SetFileNameUseUTF8",
                        p1: fileNameUseUTF8
                    },
                    {
                        name: "JITDecryptSignEnvelopeFromFile_BigData",
                        p1: strFileName,
                        P2: strFileNameOut
                    }
                ]
            };
            var JITDecryptSignEnvelopeFromFile_BigData_BatchCmdJson = JSON.stringify(JITDecryptSignEnvelopeFromFile_BigData_BatchCmd);
            return _Getretvalue(JITDecryptSignEnvelopeFromFile_BigData_BatchCmdJson);
        },


        // SymmetricEncryptFrom File
        SymmetricEncryptFromFile_file_Batch: function (strinitParam, strHashAlg, strEncAlg, strSymmetricKey, strFileName, strFileNameOut, isPad) {
            var strFileName = strFileName.replace(/\\/g, '\\\\');
            var strFileNameOut = strFileNameOut.replace(/\\/g, '\\\\');
            var SymmetricEncryptFromFile_BatchCmd = {
                name: "BatchCmd",
                Items: [{
                        name: "RegisterParam",
                        p1: strinitParam
                    },
                    {
                        name: "SetAlgorithm",
                        p1: strHashAlg,
                        P2: strEncAlg
                    },
                    {
                        name: "SymmetricEncryptFromFile",
                        p1: strSymmetricKey,
                        P2: strFileName,
                        P3: strFileNameOut,
                        P4: isPad
                    }
                ]
            };
            var SymmetricEncryptFromFile_BatchCmdJson = JSON.stringify(SymmetricEncryptFromFile_BatchCmd);
            return _Getretvalue(SymmetricEncryptFromFile_BatchCmdJson);
        },
        // SymmetricDecryptFromFile
        SymmetricDecryptFromFile_file_Batch: function (strinitParam, strHashAlg, strEncAlg, strSymmetricKey, strFileName, strFileNameOut, isPad) {

            var strFileName = strFileName.replace(/\\/g, '\\\\');
            var strFileNameOut = strFileNameOut.replace(/\\/g, '\\\\');
            var SymmetricDecryptFromFile_BatchCmd = {
                name: "BatchCmd",
                Items: [{
                        name: "RegisterParam",
                        p1: strinitParam
                    },
                    {
                        name: "SetAlgorithm",
                        p1: strHashAlg,
                        P2: strEncAlg
                    },
                    {
                        name: "SymmetricDecryptFromFile",
                        p1: strSymmetricKey,
                        P2: strFileName,
                        P3: strFileNameOut,
                        P4: isPad
                    }
                ]
            };
            var SymmetricDecryptFromFile_BatchCmdJson = JSON.stringify(SymmetricDecryptFromFile_BatchCmd);
            return _Getretvalue(SymmetricDecryptFromFile_BatchCmdJson);
        },


        //S2EncryptEnvelop File
        S2EncryptEnvelop_file_Batch: function (strinitParam, types, strCertType, strDN, strSN, strEmail, strDNIssuer, strCertBase64, fileNameUseUTF8, strdn, strFileName, strFileNameOut1, strFileNameOut2) {
            var strFileName = strFileName.replace(/\\/g, '\\\\');
            var strFileNameOut1 = strFileNameOut1.replace(/\\/g, '\\\\');
            var strFileNameOut2 = strFileNameOut2.replace(/\\/g, '\\\\');
            var S2EncryptEnvelop_BatchCmdCmd = {
                name: "BatchCmd",
                Items: [{
                        name: "RegisterParam",
                        p1: strinitParam
                    },
                    {
                        name: "SetCertChooseType",
                        p1: types
                    },
                    {
                        name: "SetCert",
                        p1: strCertType,
                        p2: strDN,
                        p3: strSN,
                        p4: strEmail,
                        p5: strDNIssuer,
                        p6: strCertBase64
                    },
                    {
                        name: "SetFileNameUseUTF8",
                        p1: fileNameUseUTF8
                    },
                    {
                        name: "S2EncryptEnvelop",
                        p1: strdn,
                        p2: strFileName,
                        p3: strFileNameOut1,
                        p4: strFileNameOut2
                    }
                ]
            };
            var S2EncryptEnvelop_BatchCmdCmdJson = JSON.stringify(S2EncryptEnvelop_BatchCmdCmd);
            return _Getretvalue(S2EncryptEnvelop_BatchCmdCmdJson);
        },


        //S2UnEncryptEnvelop file
        S2UnEncryptEnvelop_file_Batch: function (strinitParam, fileNameUseUTF8, strFileName1, strFileName2, strFileNameOut) {
            var strFileName1 = strFileName1.replace(/\\/g, '\\\\');
            var strFileName2 = strFileName2.replace(/\\/g, '\\\\');
            var strFileNameOut = strFileNameOut.replace(/\\/g, '\\\\');
            var S2UnEncryptEnvelop_BatchCmd = {
                name: "BatchCmd",
                Items: [{
                        name: "RegisterParam",
                        p1: strinitParam
                    },
                    {
                        name: "SetFileNameUseUTF8",
                        p1: fileNameUseUTF8
                    },
                    {
                        name: "S2UnEncryptEnvelop",
                        p1: strFileName1,
                        p2: strFileName2,
                        p3: strFileNameOut
                    }
                ]
            };
            var S2UnEncryptEnvelop_BatchCmdJson = JSON.stringify(S2UnEncryptEnvelop_BatchCmd);
            return _Getretvalue(S2UnEncryptEnvelop_BatchCmdJson);
        },

        //s2envelop_big_multicert_batch
        S2EncryptEnvelop_multicert_file_twocert_Batch: function (strinitParam, types, DSign_Cert, DSign_Cert1, DSign_Cert2, fileNameUseUTF8, strdn, strFileName, strFileNameOut1, strFileNameOut2) {
            var strFileName = strFileName.replace(/\\/g, '\\\\');
            var strFileNameOut1 = strFileNameOut1.replace(/\\/g, '\\\\');
            var strFileNameOut2 = strFileNameOut2.replace(/\\/g, '\\\\');
            var S2EncryptEnvelop_BatchCmd = {
                name: "BatchCmd",
                Items: [{
                        name: "RegisterParam",
                        p1: strinitParam
                    },
                    {
                        name: "SetCertChooseType",
                        p1: types
                    },
                    {
                        name: "SetCertByBase64Ex",
                        p1: DSign_Cert
                    },
                    {
                        name: "SetCertByBase64Ex",
                        p1: DSign_Cert1
                    },
                    {
                        name: "SetCertByBase64Ex",
                        p1: DSign_Cert2
                    },
                    {
                        name: "SetFileNameUseUTF8",
                        p1: fileNameUseUTF8
                    },
                    {
                        name: "S2EncryptEnvelop",
                        p1: strdn,
                        p2: strFileName,
                        p3: strFileNameOut1,
                        p4: strFileNameOut2
                    }
                ]
            };
            var S2EncryptEnvelop_BatchCmdJson = JSON.stringify(S2EncryptEnvelop_BatchCmd);
            return _Getretvalue(S2EncryptEnvelop_BatchCmdJson);
        },

        //s2envelop_big_multicert_batch 一个cert
        S2EncryptEnvelop_multicert_file_Batch: function (strinitParam, types, DSign_Cert, DSign_Cert1, fileNameUseUTF8, strdn, strFileName, strFileNameOut1, strFileNameOut2) {
            var strFileName = strFileName.replace(/\\/g, '\\\\');
            var strFileNameOut1 = strFileNameOut1.replace(/\\/g, '\\\\');
            var strFileNameOut2 = strFileNameOut2.replace(/\\/g, '\\\\');
            var S2EncryptEnvelop_BatchCmd = {
                name: "BatchCmd",
                Items: [{
                    name: "RegisterParam",
                    p1: strinitParam
                },
                    {
                        name: "SetCertChooseType",
                        p1: types
                    },
                    {
                        name: "SetCertByBase64Ex",
                        p1: DSign_Cert
                    },
                    {
                        name: "SetCertByBase64Ex",
                        p1: DSign_Cert1
                    },
                    {
                        name: "SetFileNameUseUTF8",
                        p1: fileNameUseUTF8
                    },
                    {
                        name: "S2EncryptEnvelop",
                        p1: strdn,
                        p2: strFileName,
                        p3: strFileNameOut1,
                        p4: strFileNameOut2
                    }
                ]
            };
            var S2EncryptEnvelop_BatchCmdJson = JSON.stringify(S2EncryptEnvelop_BatchCmd);
            return _Getretvalue(S2EncryptEnvelop_BatchCmdJson);
        },


        // senvelop_big File
        SEncryptEnvelop_file_Batch: function (strinitParam, fileNameUseUTF8, types, strCertType, strDN, strSN, strEmail, strDNIssuer, strCertBase64, strdn, strFileName, strFileNameOut1) {
            var strFileName = strFileName.replace(/\\/g, '\\\\');
            var strFileNameOut1 = strFileNameOut1.replace(/\\/g, '\\\\');
            var SEncryptEnvelop_BatchCmd = {
                name: "BatchCmd",
                Items: [{
                        name: "RegisterParam",
                        p1: strinitParam
                    },
                    {
                        name: "SetCertChooseType",
                        p1: types
                    },
                    {
                        name: "SetCert",
                        p1: strCertType,
                        p2: strDN,
                        p3: strSN,
                        p4: strEmail,
                        p5: strDNIssuer,
                        p6: strCertBase64
                    },
                    {
                        name: "SetFileNameUseUTF8",
                        p1: fileNameUseUTF8
                    },
                    {
                        name: "SEncryptEnvelop",
                        p1: strdn,
                        p2: strFileName,
                        p3: strFileNameOut1
                    }
                ]
            };
            var SEncryptEnvelop_BatchCmdJson = JSON.stringify(SEncryptEnvelop_BatchCmd);
            return _Getretvalue(SEncryptEnvelop_BatchCmdJson);
        },


        //SUnEncryptEnvelop Batch
        SUnEncryptEnvelop_file_Batch: function (strinitParam, fileNameUseUTF8, strFileNamein, strFileNameOut) {
            var strFileNamein = strFileNamein.replace(/\\/g, '\\\\');
            var strFileNameOut = strFileNameOut.replace(/\\/g, '\\\\');
            var SUnEncryptEnvelop_BatchCmd = {
                name: "BatchCmd",
                Items: [{
                        name: "RegisterParam",
                        p1: strinitParam
                    },
                    {
                        name: "SetFileNameUseUTF8",
                        p1: fileNameUseUTF8
                    },
                    {
                        name: "SUnEncryptEnvelop",
                        p1: strFileNamein,
                        p2: strFileNameOut
                    }
                ]
            };
            var SUnEncryptEnvelop_BatchCmdJson = JSON.stringify(SUnEncryptEnvelop_BatchCmd);
            return _Getretvalue(SUnEncryptEnvelop_BatchCmdJson);
        },

        //senvelop_big_multicert_batch
        SEncryptEnvelop_multicert_file_twocert_Batch: function (strinitParam, types, DSign_Cert, DSign_Cert1, DSign_Cert2, fileNameUseUTF8, strdn, strFileName, strFileNameOut1) {
            var strFileName = strFileName.replace(/\\/g, '\\\\');
            var strFileNameOut1 = strFileNameOut1.replace(/\\/g, '\\\\');
            var SEncryptEnvelop_BatchCmd = {
                name: "BatchCmd",
                Items: [{
                        name: "RegisterParam",
                        p1: strinitParam
                    },
                    {
                        name: "SetCertChooseType",
                        p1: types
                    },
                    {
                        name: "SetCertByBase64Ex",
                        p1: DSign_Cert
                    },
                    {
                        name: "SetCertByBase64Ex",
                        p1: DSign_Cert1
                    },
                    {
                        name: "SetCertByBase64Ex",
                        p1: DSign_Cert2
                    },
                    {
                        name: "SetFileNameUseUTF8",
                        p1: fileNameUseUTF8
                    },
                    {
                        name: "SEncryptEnvelop",
                        p1: strdn,
                        p2: strFileName,
                        p3: strFileNameOut1
                    }
                ]
            };
            var SEncryptEnvelop_BatchCmdJson = JSON.stringify(SEncryptEnvelop_BatchCmd);
            return _Getretvalue(SEncryptEnvelop_BatchCmdJson);
        },

        //senvelop_big_multicert_batch 一个证书
        SEncryptEnvelop_multicert_file_Batch: function (strinitParam, types, DSign_Cert, DSign_Cert1, fileNameUseUTF8, strdn, strFileName, strFileNameOut1) {
            var strFileName = strFileName.replace(/\\/g, '\\\\');
            var strFileNameOut1 = strFileNameOut1.replace(/\\/g, '\\\\');
            var SEncryptEnvelop_BatchCmd = {
                name: "BatchCmd",
                Items: [{
                        name: "RegisterParam",
                        p1: strinitParam
                    },
                    {
                        name: "SetCertChooseType",
                        p1: types
                    },
                    {
                        name: "SetCertByBase64Ex",
                        p1: DSign_Cert
                    },
                    {
                        name: "SetCertByBase64Ex",
                        p1: DSign_Cert1
                    },
                    {
                        name: "SetFileNameUseUTF8",
                        p1: fileNameUseUTF8
                    },
                    {
                        name: "SEncryptEnvelop",
                        p1: strdn,
                        p2: strFileName,
                        p3: strFileNameOut1
                    }
                ]
            };
            var SEncryptEnvelop_BatchCmdJson = JSON.stringify(SEncryptEnvelop_BatchCmd);
            return _Getretvalue(SEncryptEnvelop_BatchCmdJson);
        },

        /******file  batch end*****/
        MOF_SetFlag: function (types) {
            var MOF_SetFlagCmd = {
                name: "MOF_SetFlag",
                p1: types
            };
            var MOF_SetFlagCmdJson = JSON.stringify(MOF_SetFlagCmd);
            return _Getretcode(MOF_SetFlagCmdJson);
        },
        MOF_DetachSignStr: function (strdn, iscert, strsrc, strserverinfo) {
            var MOF_DetachSignStrCmd = {
                name: "MOF_DetachSignStr",
                p1: strdn,
                p2: iscert,
                p3: strsrc,
                p4: strserverinfo
            };
            var MOF_DetachSignStrCmdJson = JSON.stringify(MOF_DetachSignStrCmd);
            return _Getretmsg(MOF_DetachSignStrCmdJson);
        },
        MOF_DetachSignBase64Str: function (strdn, iscert, strsrc, strserverinfo) {
            var MOF_DetachSignBase64StrCmd = {
                name: "MOF_DetachSignBase64Str",
                p1: strdn,
                p2: iscert,
                p3: strsrc,
                p4: strserverinfo
            };
            var MOF_DetachSignBase64StrCmdJson = JSON.stringify(MOF_DetachSignBase64StrCmd);
            return _Getretmsg(MOF_DetachSignBase64StrCmdJson);
        },
        MOF_VerifyDetachedSignStr: function (strSignedData, strsrc) {
            var MOF_VerifyDetachedSignStrCmd = {
                name: "MOF_VerifyDetachedSignStr",
                p1: strSignedData,
                p2: strsrc
            };
            var MOF_VerifyDetachedSignStrCmdJson = JSON.stringify(MOF_VerifyDetachedSignStrCmd);
            return _Getretcode(MOF_VerifyDetachedSignStrCmdJson);
        },
        MOF_EncryptEnvelopStr: function (strdn, strsrc, strserverinfo) {
            var MOF_EncryptEnvelopStrCmd = {
                name: "MOF_EncryptEnvelopStr",
                p1: strdn,
                p2: strsrc,
                p3: strserverinfo
            };
            var MOF_EncryptEnvelopStrCmdJson = JSON.stringify(MOF_EncryptEnvelopStrCmd);
            return _Getretmsg(MOF_EncryptEnvelopStrCmdJson);
        },
        MOF_EncryptEnvelopBase64Str: function (strdn, strsrc, strserverinfo) {
            var MOF_EncryptEnvelopBase64StrCmd = {
                name: "MOF_EncryptEnvelopBase64Str",
                p1: strdn,
                p2: strsrc,
                p3: strserverinfo
            };
            var MOF_EncryptEnvelopBase64StrCmdJson = JSON.stringify(MOF_EncryptEnvelopBase64StrCmd);
            return _Getretmsg(MOF_EncryptEnvelopBase64StrCmdJson);
        },
        MOF_DecryptEnvelop: function (strEnvelop) {
            var MOF_DecryptEnvelopCmd = {
                name: "MOF_DecryptEnvelop",
                p1: strEnvelop
            };
            var MOF_DecryptEnvelopCmdJson = JSON.stringify(MOF_DecryptEnvelopCmd);
            return _Getretcode(MOF_DecryptEnvelopCmdJson);
        },
        GetKeyDevInfoByCertSN: function (strdn, ntype) {
            var GetKeyDevInfoByCertSNCmd = {
                name: "GetKeyDevInfoByCertSN",
                p1: strdn,
                p2: ntype
            };
            var GetKeyDevInfoByCertSNCmdJson = JSON.stringify(GetKeyDevInfoByCertSNCmd);
            return _Getretmsg(GetKeyDevInfoByCertSNCmdJson);
        },
        GetKeyDevInfo: function () {
            var GetKeyDevInfoCmd = {
                name: "GetKeyDevInfo"
            };
            var GetKeyDevInfoCmdJson = JSON.stringify(GetKeyDevInfoCmd); //转换为json字符串
            return _Getretmsg(GetKeyDevInfoCmdJson);
        },
        //file
        DigestFromFile: function (strSrcFileName) {
            //  var strFileName = strSrcFileName.replace(/\\/g,'\\\\');
            var DigestFromFileCmd = {
                name: "DigestFromFile",
                p1: strSrcFileName
            };
            var DigestFromFileCmdJson = JSON.stringify(DigestFromFileCmd); //转换为json字符串
            return _Getretmsg(DigestFromFileCmdJson);
        },
        SetFileNameUseUTF8: function (isUTF8) {
            var SetFileNameUseUTF8Cmd = {
                name: "SetFileNameUseUTF8",
                p1: isUTF8
            };
            var SetFileNameUseUTF8CmdJson = JSON.stringify(SetFileNameUseUTF8Cmd);
            return _Getretcode(SetFileNameUseUTF8CmdJson);
        },SetFileNameUseUniCode:function (isUTF8) {
            var SetFileNameUseUniCodeCmd = {
                name: "SetFileNameUseUniCode",
                p1: isUTF8
            };
            var SetFileNameUseUniCodeCmdJson = JSON.stringify(SetFileNameUseUniCodeCmd);
            return _Getretcode(SetFileNameUseUniCodeCmdJson);
        },
        AttachSignEx: function (strDN, strFileName, strFileNameOut) {
            var strFileName1 = strFileName.replace(/\\/g, '\\\\');
            var strFileName2 = strFileNameOut.replace(/\\/g, '\\\\');
            var AttachSignExCmd = {
                name: "AttachSignEx",
                p1: strDN,
                p2: strFileName1,
                p3: strFileName2
            };
            var AttachSignExCmdJson = JSON.stringify(AttachSignExCmd);
            return _Getretmsg(AttachSignExCmdJson);
        },
        VerifyAttachedSignEx: function (strFileNameAttached) {
            var strFileName = strFileNameAttached.replace(/\\/g, '\\\\');
            var VerifyAttachedSignExCmd = {
                name: "VerifyAttachedSignEx",
                p1: strFileName
            };
            var VerifyAttachedSignExCmdJson = JSON.stringify(VerifyAttachedSignExCmd);
            return _Getretcode(VerifyAttachedSignExCmdJson);
        },
        GetFile: function (strFileSavePath) {
            var strFileName = strFileSavePath.replace(/\\/g, '\\\\');
            var GetFileCmd = {
                name: "GetFile",
                p1: strFileName
            };
            var GetFileCmdJson = JSON.stringify(GetFileCmd);
            return _Getretmsg(GetFileCmdJson);
        },
        JITVerifyAttachFromFile_BigData: function (strInFileName, strOutFilePath) {
            var strFileName1 = strInFileName.replace(/\\/g, '\\\\');
            var strFileName2 = strOutFilePath.replace(/\\/g, '\\\\');
            var JITVerifyAttachFromFile_BigDataCmd = {
                name: "JITVerifyAttachFromFile_BigData",
                p1: strFileName1,
                p2: strFileName2
            };
            var JITVerifyAttachFromFile_BigDataCmdJson = JSON.stringify(JITVerifyAttachFromFile_BigDataCmd); //转换为json字符串
            return _Getretcode(JITVerifyAttachFromFile_BigDataCmdJson);
        },
        JITAttachFromFile_BigData: function (strCertDN, strSrcFileName, strOutFileName) {
            var strFileName1 = strSrcFileName.replace(/\\/g, '\\\\');
            var strFileName2 = strOutFileName.replace(/\\/g, '\\\\');
            var JITAttachFromFile_BigDataCmd = {
                name: "JITAttachFromFile_BigData",
                p1: strCertDN,
                p2: strFileName1,
                p3: strFileName2
            };
            var JITAttachFromFile_BigDataCmdJson = JSON.stringify(JITAttachFromFile_BigDataCmd); //转换为json字符串
            return _Getretcode(JITAttachFromFile_BigDataCmdJson);
        },
        DetachSignEx: function (strDN, strFileName, strFileNameOut) {
            //  var strFileName1 = strFileName.replace(/\\/g,'\\\\');
            //  var strFileName2 = strFileNameOut.replace(/\\/g,'\\\\');
            var DetachSignExCmd = {
                name: "DetachSignEx",
                p1: strDN,
                p2: strFileName,
                p3: strFileNameOut
            };
            var DetachSignExCmdJson = JSON.stringify(DetachSignExCmd); //转换为json字符串
            return _Getretmsg(DetachSignExCmdJson);
        },
        JITDetachFromFile_BigData: function (strCertDN, strSrcFileName, strOutFileName) {
            //  var strFileName1 = strSrcFileName.replace(/\\/g,'\\\\');
            //  var strFileName2 = strOutFileName.replace(/\\/g,'\\\\');
            var JITDetachFromFile_BigDataCmd = {
                name: "JITDetachFromFile_BigData",
                p1: strCertDN,
                p2: strSrcFileName,
                p3: strOutFileName
            };
            var JITDetachFromFile_BigDataCmdJson = JSON.stringify(JITDetachFromFile_BigDataCmd); //转换为json字符串
            return _Getretcode(JITDetachFromFile_BigDataCmdJson);
        },
        JITDetachFromFile_BigData_Val: function (strCertDN, strSrcFileName, strOutFileName) {
            //  var strFileName1 = strSrcFileName.replace(/\\/g,'\\\\');
            //  var strFileName2 = strOutFileName.replace(/\\/g,'\\\\');
            var JITDetachFromFile_BigData_ValCmd = {
                name: "JITDetachFromFile_BigData_Val",
                p1: strCertDN,
                p2: strSrcFileName,
                p3: strOutFileName
            };
            var JITDetachFromFile_BigData_ValCmdJson = JSON.stringify(JITDetachFromFile_BigData_ValCmd); //转换为json字符串
            return _Getretmsg(JITDetachFromFile_BigData_ValCmdJson);
        },
        VerifyDetachedSignEx: function (strSignedData, strFileNameDetached, strFileName) {
            var strFileName1 = strFileNameDetached.replace(/\\/g, '\\\\');
            var strFileName2 = strFileName.replace(/\\/g, '\\\\');
            var VerifyDetachedSignExCmd = {
                name: "VerifyDetachedSignEx",
                p1: strSignedData,
                p2: strFileName1,
                p3:strFileName2
            };
            var VerifyDetachedSignExCmdJson = JSON.stringify(VerifyDetachedSignExCmd);
            return _Getretcode(VerifyDetachedSignExCmdJson);
        },
        JITVerifyDetachFromFile_BigData: function (strSrcFileName, strSignFileName) {
            var strFileName1 = strSrcFileName.replace(/\\/g, '\\\\');
            var strFileName2 = strSignFileName.replace(/\\/g, '\\\\');
            var JITVerifyDetachFromFile_BigDataCmd = {
                name: "JITVerifyDetachFromFile_BigData",
                p1: strFileName1,
                p2: strFileName2
            };
            var JITVerifyDetachFromFile_BigDataCmdJson = JSON.stringify(JITVerifyDetachFromFile_BigDataCmd);
            return _Getretcode(JITVerifyDetachFromFile_BigDataCmdJson);
        },
        CreateSignedEnvelopEx: function (strSignCertDN, strEncCertDN, strFileName, strFileNameOut) {
            //  var strFileName1 = strFileName.replace(/\\/g,'\\\\');
            //  var strFileName2 = strFileNameOut.replace(/\\/g,'\\\\');
            var CreateSignedEnvelopExCmd = {
                name: "CreateSignedEnvelopEx",
                p1: strSignCertDN,
                p2: strEncCertDN,
                p3: strFileName,
                p4: strFileNameOut
            };
            var CreateSignedEnvelopExCmdJson = JSON.stringify(CreateSignedEnvelopExCmd); //转换为json字符串
            return _Getretmsg(CreateSignedEnvelopExCmdJson);
        },
        JITSignEnvelopeFromFile_BigData: function (strSignCertDN, strEncCertDN, strSrcFileName, strOutFileName) {
            //  var strFileName1 = strSrcFileName.replace(/\\/g,'\\\\');
            //  var strFileName2 = strOutFileName.replace(/\\/g,'\\\\');
            var JITSignEnvelopeFromFile_BigDataCmd = {
                name: "JITSignEnvelopeFromFile_BigData",
                p1: strSignCertDN,
                p2: strEncCertDN,
                p3: strSrcFileName,
                p4: strOutFileName
            };
            var JITSignEnvelopeFromFile_BigDataCmdJson = JSON.stringify(JITSignEnvelopeFromFile_BigDataCmd); //转换为json字符串
            return _Getretmsg(JITSignEnvelopeFromFile_BigDataCmdJson);
        },
        VerifySignedEnvelopEx: function (strEvpFile) {
            var strFileName = strEvpFile.replace(/\\/g, '\\\\');
            var VerifySignedEnvelopExCmd = {
                name: "VerifySignedEnvelopEx",
                p1: strFileName
            };
            var VerifySignedEnvelopExCmdJson = JSON.stringify(VerifySignedEnvelopExCmd);
            return _Getretcode(VerifySignedEnvelopExCmdJson);
        },
        JITDecryptSignEnvelopeFromFile_BigData: function (strInFileName, strOutFilePath) {
            var strFileName1 = strInFileName.replace(/\\/g, '\\\\');
            var strFileName2 = strOutFilePath.replace(/\\/g, '\\\\');
            var JITDecryptSignEnvelopeFromFile_BigDataCmd = {
                name: "JITDecryptSignEnvelopeFromFile_BigData",
                p1: strFileName1,
                p2: strFileName2
            };
            var JITDecryptSignEnvelopeFromFile_BigDataCmdJson = JSON.stringify(JITDecryptSignEnvelopeFromFile_BigDataCmd);
            return _Getretcode(JITDecryptSignEnvelopeFromFile_BigDataCmdJson);
        },
        SymmetricEncryptFromFile: function (strSymmetricKey, strSrcFileName, strEncryptFileName, isPad) {
            var strFileName1 = strSrcFileName.replace(/\\/g, '\\\\');
            var strFileName2 = strEncryptFileName.replace(/\\/g, '\\\\');
            var SymmetricEncryptFromFileCmd = {
             name: "SymmetricEncryptFromFile",
             p1: strSymmetricKey,
             p2: strFileName1,
             p3: strFileName2,
             p4: isPad
            };
            var SymmetricEncryptFromFileCmdJson = JSON.stringify(SymmetricEncryptFromFileCmd); //转换为json字符串
            return _Getretcode(SymmetricEncryptFromFileCmdJson);
        },
        SymmetricDecryptFromFile: function (strSymmetricKey, strEncryptFileName, strSrcFileName, isPad) {
            var strFileName1 = strEncryptFileName.replace(/\\/g, '\\\\');
            var strFileName2 = strSrcFileName.replace(/\\/g, '\\\\');
            var SymmetricDecryptFromFileCmd = {
             name: "SymmetricDecryptFromFile",
             p1: strSymmetricKey,
             p2: strFileName1,
             p3: strFileName2,
             p4: isPad
            };
            var SymmetricDecryptFromFileCmdJson = JSON.stringify(SymmetricDecryptFromFileCmd); //转换为json字符串
            return _Getretcode(SymmetricDecryptFromFileCmdJson);
        },
        EncryptEnvelopEx: function (strDN, strFileName, strFileNameOut) {
            //  var strFileName1 = strFileName.replace(/\\/g,'\\\\');
            //  var strFileName2 = strFileNameOut.replace(/\\/g,'\\\\');
            var EncryptEnvelopExCmd = {
                name: "EncryptEnvelopEx",
                p1: strDN,
                p2: strFileName,
                p3: strFileNameOut
            };
            var EncryptEnvelopExCmdJson = JSON.stringify(EncryptEnvelopExCmd); //转换为json字符串
            return _Getretmsg(EncryptEnvelopExCmdJson);
        },
        DecryptEnvelopEx: function (strFileName) {
            var strFileName = strFileName.replace(/\\/g, '\\\\');
            var DecryptEnvelopExCmd = {
                name: "DecryptEnvelopEx",
                p1: strFileName
            };
            var DecryptEnvelopExCmdJson = JSON.stringify(DecryptEnvelopExCmd); //转换为json字符串
            return _Getretcode(DecryptEnvelopExCmdJson);
        },
        Http_Batch: function (str) {

            return _Getretvalue(str);
        },
        JITCreateEnvelopeFromFile_BigData: function (strDN, strFileName, strFileNameOut) {
            //  var strFileName1 = strFileName.replace(/\\/g,'\\\\');
            //  var strFileName2 = strFileNameOut.replace(/\\/g,'\\\\');
            var JITCreateEnvelopeFromFile_BigDataCmd = {
                name: "JITCreateEnvelopeFromFile_BigData",
                p1: strDN,
                p2: strFileName,
                p3: strFileNameOut
            };
            var JITCreateEnvelopeFromFile_BigDataCmdJson = JSON.stringify(JITCreateEnvelopeFromFile_BigDataCmd); //转换为json字符串
            return _Getretcode(JITCreateEnvelopeFromFile_BigDataCmdJson);
        },
        JITDecryptEnvelopeFromFile_BigData: function (strInFileName, strOutFilePath) {
            var strFileName1 = strInFileName.replace(/\\/g, '\\\\');
            var strFileName2 = strOutFilePath.replace(/\\/g, '\\\\');
            var JITDecryptEnvelopeFromFile_BigDataCmd = {
                name: "JITDecryptEnvelopeFromFile_BigData",
                p1: strFileName1,
                p2: strFileName2
            };
            var JITDecryptEnvelopeFromFile_BigDataCmdJson = JSON.stringify(JITDecryptEnvelopeFromFile_BigDataCmd); //转换为json字符串
            return _Getretcode(JITDecryptEnvelopeFromFile_BigDataCmdJson);

        },
        SEncryptEnvelop: function (strCertDN, strSrcFileName, strOutFileName) {
            //  var strFileName1 = strSrcFileName.replace(/\\/g,'\\\\');
            //  var strFileName2 = strOutFileName.replace(/\\/g,'\\\\');
            var SEncryptEnvelopCmd = {
                name: "SEncryptEnvelop",
                p1: strCertDN,
                p2: strSrcFileName,
                p3: strOutFileName
            };
            var SEncryptEnvelopCmdJson = JSON.stringify(SEncryptEnvelopCmd); //转换为json字符串
            return _Getretcode(SEncryptEnvelopCmdJson);
        },
        SUnEncryptEnvelop: function (strInFileName, strOutFileName) {
            //  var strFileName1 = strInFileName.replace(/\\/g,'\\\\');
            //  var strFileName2 = strOutFileName.replace(/\\/g,'\\\\');
            var SUnEncryptEnvelopCmd = {
                name: "SUnEncryptEnvelop",
                p1: strInFileName,
                p2: strOutFileName
            };
            var SUnEncryptEnvelopCmdJson = JSON.stringify(SUnEncryptEnvelopCmd); //转换为json字符串
            return _Getretcode(SUnEncryptEnvelopCmdJson);
        },
        S2EncryptEnvelop: function (strCertDN, strSrcFileName, strOutFileName1, strOutFileName2) {
            //  var strFileName1 = strSrcFileName.replace(/\\/g,'\\\\');
            //  var strFileName2 = strOutFileName1.replace(/\\/g,'\\\\');
            //  var strFileName3 = strOutFileName2.replace(/\\/g,'\\\\');
            var S2EncryptEnvelopCmd = {
                name: "S2EncryptEnvelop",
                p1: strCertDN,
                p2: strSrcFileName,
                p3: strOutFileName1,
                p4: strOutFileName2
            };
            var S2EncryptEnvelopCmdJson = JSON.stringify(S2EncryptEnvelopCmd); //转换为json字符串
            return _Getretcode(S2EncryptEnvelopCmdJson);
        },
        S2UnEncryptEnvelop: function (strInFileName1, strInFileName2, strOutFileName) {
            //  var strFileName1 = strInFileName1.replace(/\\/g,'\\\\');
            //  var strFileName2 = strInFileName2.replace(/\\/g,'\\\\');
            //  var strFileName3 = strOutFileName.replace(/\\/g,'\\\\');
            var S2UnEncryptEnvelopCmd = {
                name: "S2UnEncryptEnvelop",
                p1: strInFileName1,
                p2: strInFileName2,
                p3: strOutFileName
            };
            var S2UnEncryptEnvelopCmdJson = JSON.stringify(S2UnEncryptEnvelopCmd); //转换为json字符串
            return _Getretcode(S2UnEncryptEnvelopCmdJson);
        },
        JITGDigestStr: function (strAlg, strSrcData, isBase64) {
            var JITGDigestStrCmd = {
                name: "JITGDigestStr",
                p1: strAlg,
                p2: strSrcData,
                p3: isBase64
            };
            var JITGDigestStrCmdJson = JSON.stringify(JITGDigestStrCmd);
            return _Getretmsg(JITGDigestStrCmdJson);
        },
        JITDigest: function (strAlg, strSrcData, isZ) {
            var JITDigestCmd = {
                name: "JITDigest",
                p1: strAlg,
                p2: strSrcData,
                p3: isZ
            };
            var JITDigestCmdJson = JSON.stringify(JITDigestCmd);
            return _Getretmsg(JITDigestCmdJson);
        },
        JITGAsymmetricEncryptStr: function (strPublicKey, nIsPublicKeyCert, strSrcData, nIsBase64, nAlgFlag) {
            var JITGAsymmetricEncryptStrCmd = {
                name: "JITGAsymmetricEncryptStr",
                p1: strPublicKey,
                p2: nIsPublicKeyCert,
                p3: strSrcData,
                p4: nIsBase64,
                p5: nAlgFlag
            };
            var JITGAsymmetricEncryptStrCmdJson = JSON.stringify(JITGAsymmetricEncryptStrCmd);
            return _Getretmsg(JITGAsymmetricEncryptStrCmdJson);
        },
        JITGAsymmetricDecryptStr: function (strPrivatekey, strEnData, nIsBase64, nAlgFlag) {
            var JITGAsymmetricDecryptStrCmd = {
                name: "JITGAsymmetricDecryptStr",
                p1: strPrivatekey,
                p2: strEnData,
                p3: nIsBase64,
                p4: nAlgFlag
            };
            var JITGAsymmetricDecryptStrCmdJson = JSON.stringify(JITGAsymmetricDecryptStrCmd);
            return _Getretmsg(JITGAsymmetricDecryptStrCmdJson);
        },
        JITGP7EnvelopeStr: function (bstrPunlicKeyCert, bstrSrcData, nSrcDataIsBase64, bstrSymmAlgName, bstrSymmKey, nSymmKeyIsBase64) {
            var JITGP7EnvelopeStrCmd = {
                name: "JITGP7EnvelopeStr",
                p1: bstrPunlicKeyCert,
                p2: bstrSrcData,
                p3: nSrcDataIsBase64,
                p4: bstrSymmAlgName,
                p5: bstrSymmKey,
                p6: nSymmKeyIsBase64
            };
            var JITGP7EnvelopeStrCmdJson = JSON.stringify(JITGP7EnvelopeStrCmd);
            return _Getretmsg(JITGP7EnvelopeStrCmdJson);
        },
        SymmetricEncrypt2: function (strSymmetricKey, strSrcData, uFlag) {
            var SymmetricEncrypt2Cmd = {
                name: "SymmetricEncrypt2",
                p1: strSymmetricKey,
                p2: strSrcData,
                p3: uFlag
            };
            var SymmetricEncrypt2CmdJson = JSON.stringify(SymmetricEncrypt2Cmd);
            return _Getretmsg(SymmetricEncrypt2CmdJson);
        },
        SymmetricDecrypt2: function (strSymmetricKey, strEncryptData, uFlag) {
            var SymmetricDecrypt2Cmd = {
                name: "SymmetricDecrypt2",
                p1: strSymmetricKey,
                p2: strEncryptData,
                p3: uFlag
            };
            var SymmetricDecrypt2CmdJson = JSON.stringify(SymmetricDecrypt2Cmd);
            return _Getretmsg(SymmetricDecrypt2CmdJson);
        },
        JITSymmetricEncrypt: function (strSymmetricKey, strSrcData, uFlag) {
            var JITSymmetricEncryptCmd = {
                name: "JITSymmetricEncrypt",
                p1: strSymmetricKey,
                p2: strSrcData,
                p3: uFlag
            };
            var JITSymmetricEncryptCmdJson = JSON.stringify(JITSymmetricEncryptCmd);
            return _Getretmsg(JITSymmetricEncryptCmdJson);
        },
        JITSymmetricEncryptBase64Str: function (strSymmetricKey, strSrcData,nIsBase64, uFlag) {
            var JITSymmetricEncryptBase64StrCmd = {
                name: "JITSymmetricEncryptBase64Str",
                p1: strSymmetricKey,
                p2: strSrcData,
                p3: nIsBase64,
                p4: uFlag
            };
            var JITSymmetricEncryptBase64StrCmdJson = JSON.stringify(JITSymmetricEncryptBase64StrCmd);
            return _Getretmsg(JITSymmetricEncryptBase64StrCmdJson);
        },
        JITSymmetricDecrypt: function (strSymmetricKey, strEncryptData, uFlag) {
            var JITSymmetricDecryptCmd = {
                name: "JITSymmetricDecrypt",
                p1: strSymmetricKey,
                p2: strEncryptData,
                p3: uFlag
            };
            var JITSymmetricDecryptCmdJson = JSON.stringify(JITSymmetricDecryptCmd);
            return _Getretmsg(JITSymmetricDecryptCmdJson);
        },
        JITRandomNumber: function (randomLength) {
            var JITRandomNumberCmd = {
                name: "JITRandomNumber",
                p1: randomLength
            };
            var JITRandomNumberCmdJson = JSON.stringify(JITRandomNumberCmd);
            return _Getretmsg(JITRandomNumberCmdJson);
        },
        JITP1SignStr: function (bstrHashAlg, ORG_DATA, nIsBase64) {
            var JITP1SignStrCmd = {
                name: "JITP1SignStr",
                p1: bstrHashAlg,
                p2: ORG_DATA,
                p3: nIsBase64
            };
            var JITP1SignStrCmdJson = JSON.stringify(JITP1SignStrCmd);
            return _Getretmsg(JITP1SignStrCmdJson);
        },
        JITP1VerifyStr: function (bstrHashAlg, strP1Date, strSrcData, nIsBase64) {
            var JITP1VerifyStrCmd = {
                name: "JITP1VerifyStr",
                p1: bstrHashAlg,
                p2: strP1Date,
                p3: strSrcData,
                p4: nIsBase64
            };
            var JITP1VerifyStrCmdJson = JSON.stringify(JITP1VerifyStrCmd);
            return _Getretmsg(JITP1VerifyStrCmdJson);
        },
        P1SignOtherStr: function (strSignCertDN, ORG_DATA, nIsBase64) {
            var P1SignOtherStrCmd = {
                name: "P1SignOtherStr",
                p1: strSignCertDN,
                p2: ORG_DATA,
                p3: nIsBase64
            };
            var P1SignOtherStrCmdJson = JSON.stringify(P1SignOtherStrCmd);
            return _Getretmsg(P1SignOtherStrCmdJson);
        },
        JITHMacStr: function (symmkey, ORG_DATA, nIsBase64) {
            var JITHMacStrCmd = {
                name: "JITHMacStr",
                p1: symmkey,
                p2: ORG_DATA,
                p3: nIsBase64
            };
            var JITHMacStrCmdJson = JSON.stringify(JITHMacStrCmd);
            return _Getretmsg(JITHMacStrCmdJson);
        },
        JITHMacStrByAlg: function (symmkey, keyBase64, ORG_DATA, nIsBase64, nAlgFlag) {
            var JITHMacStrByAlgCmd = {
                name: "JITHMacStrByAlg",
                p1: symmkey,
                p2: keyBase64,
                p3: ORG_DATA,
                p4: nIsBase64,
                p5: nAlgFlag
            };
            var JITHMacStrByAlgCmdJson = JSON.stringify(JITHMacStrByAlgCmd);
            return _Getretmsg(JITHMacStrByAlgCmdJson);
        },
        JITWriteDataStrToKey: function (bstrFileName, ORG_DATA, nIsBase64) {
            var JITWriteDataStrToKeyCmd = {
                name: "JITWriteDataStrToKey",
                p1: bstrFileName,
                p2: ORG_DATA,
                p3: nIsBase64
            };
            var JITWriteDataStrToKeyCmdJson = JSON.stringify(JITWriteDataStrToKeyCmd);
            return _Getretmsg(JITWriteDataStrToKeyCmdJson);
        },
        JITWriteDatasStrToKey: function (bstrFileName, ORG_DATA, bstrFileName1, ORG_DATA1, nIsBase64) {
            var JITWriteDatasStrToKeyCmd = {
                name: "JITWriteDatasStrToKey",
                p1: bstrFileName,
                p2: ORG_DATA,
                p3: bstrFileName1,
                p4: ORG_DATA1,
                p5: nIsBase64
            };
            var JITWriteDatasStrToKeyCmdJson = JSON.stringify(JITWriteDatasStrToKeyCmd);
            return _Getretmsg(JITWriteDatasStrToKeyCmdJson);
        },
        JITReadDataFromKey: function (bstrFileName) {
            var JITReadDataFromKeyCmd = {
                name: "JITReadDataFromKey",
                p1: bstrFileName
            };
            var JITReadDataFromKeyCmdJson = JSON.stringify(JITReadDataFromKeyCmd); //转换为json字符串
            return _Getretmsg(JITReadDataFromKeyCmdJson);
        },
        JITDelFileFromKey: function (bstrFileName) {
            var JITDelFileFromKeyCmd = {
                name: "JITDelFileFromKey",
                p1: bstrFileName
            };
            var JITDelFileFromKeyCmdJson = JSON.stringify(JITDelFileFromKeyCmd); //转换为json字符串
            return _Getretmsg(JITDelFileFromKeyCmdJson);
        },
        JITEPS_ReadESealData: function () {
            var JITEPS_ReadESealDataCmd = {
                name: "JITEPS_ReadESealData"
            };
            var JITEPS_ReadESealDataCmdJson = JSON.stringify(JITEPS_ReadESealDataCmd); //转换为json字符串
            return _Getretmsg(JITEPS_ReadESealDataCmdJson);
        },
        JITEPS_WriteESealDataStr: function (bstrData, nIsBase64) {
            var JITEPS_WriteESealDataStrCmd = {
                name: "JITEPS_WriteESealDataStr",
                p1: bstrData,
                p2: nIsBase64
            };
            var JITEPS_WriteESealDataStrCmdJson = JSON.stringify(JITEPS_WriteESealDataStrCmd); //转换为json字符串
            return _Getretmsg(JITEPS_WriteESealDataStrCmdJson);
        },
        JITP7AttachVerifySignTsaStr: function (strSignedData) {
            var JITP7AttachVerifySignTsaStrCmd = {
                name: "JITP7AttachVerifySignTsaStr",
                p1: strSignedData
            };
            var JITP7AttachVerifySignTsaStrCmdJson = JSON.stringify(JITP7AttachVerifySignTsaStrCmd); //转换为json字符串
            return _Getretcode(JITP7AttachVerifySignTsaStrCmdJson);
        },
        JITP7DetachVerifySignTsaStr: function (strSignedData, ORG_DATA, nIsBase64) {
            var JITP7DetachVerifySignTsaStrCmd = {
                name: "JITP7DetachVerifySignTsaStr",
                p1: strSignedData,
                p2: ORG_DATA,
                p3: nIsBase64
            };
            var JITP7DetachVerifySignTsaStrCmdJson = JSON.stringify(JITP7DetachVerifySignTsaStrCmd); //转换为json字符串
            return _Getretcode(JITP7DetachVerifySignTsaStrCmdJson);
        },
        JITVerifyTsaStr: function (strSignedData) {
            var JITVerifyTsaStrCmd = {
                name: "JITVerifyTsaStr",
                p1: strSignedData
            };
            var JITVerifyTsaStrCmdJson = JSON.stringify(JITVerifyTsaStrCmd); //转换为json字符串
            return _Getretcode(JITVerifyTsaStrCmdJson);
        },
        JITGP7AttachVerifySignTsaStr: function (strSignedData) {
            var JITGP7AttachVerifySignTsaStrCmd = {
                name: "JITGP7AttachVerifySignTsaStr",
                p1: strSignedData
            };
            var JITGP7AttachVerifySignTsaStrCmdJson = JSON.stringify(JITGP7AttachVerifySignTsaStrCmd); //转换为json字符串
            return _Getretcode(JITGP7AttachVerifySignTsaStrCmdJson);
        },
        JITGP7DetachVerifySignTsaStr: function (strSignedData, ORG_DATA, nIsBase64) {
            var JITGP7DetachVerifySignTsaStrCmd = {
                name: "JITGP7DetachVerifySignTsaStr",
                p1: strSignedData,
                p2: ORG_DATA,
                p3: nIsBase64
            };
            var JITGP7DetachVerifySignTsaStrCmdJson = JSON.stringify(JITGP7DetachVerifySignTsaStrCmd); //转换为json字符串
            return _Getretcode(JITGP7DetachVerifySignTsaStrCmdJson);
        },
        JITGVerifyTsaStr: function (strSignedData) {
            var JITGVerifyTsaStrCmd = {
                name: "JITGVerifyTsaStr",
                p1: strSignedData
            };
            var JITGVerifyTsaStrCmdJson = JSON.stringify(JITGVerifyTsaStrCmd); //转换为json字符串
            return _Getretcode(JITGVerifyTsaStrCmdJson);
        },
        JITGParseEnvelopeStr: function (strEnvelopData) {
            var JITGParseEnvelopeStrCmd = {
                name: "JITGParseEnvelopeStr",
                p1: strEnvelopData
            };
            var JITGParseEnvelopeStrCmdJson = JSON.stringify(JITGParseEnvelopeStrCmd); //转换为json字符串
            return _Getretcode(JITGParseEnvelopeStrCmdJson);
        },
        GetDigestAlg: function () {
            var GetDigestAlgCmd = {
                name: "GetDigestAlg"
            };
            var GetDigestAlgCmdJson = JSON.stringify(GetDigestAlgCmd);
            return _Getretcode(GetDigestAlgCmdJson);
        },
        GetTsaTimeData: function () {
            var GetTsaTimeDataCmd = {
                name: "GetTsaTimeData"
            };
            var GetTsaTimeDataCmdJson = JSON.stringify(GetTsaTimeDataCmd); //转换为json字符串
            return _Getretmsg(GetTsaTimeDataCmdJson);
        },
        GetTsaHashAlgName: function () {
            return _GetTsaHashAlgName();
        },
        JIT_RandomNumber16: function (randomLength) {
            var JIT_RandomNumber16Cmd = {
                name: "JIT_RandomNumber16",
                p1: randomLength
            };
            var JIT_RandomNumber16CmdJson = JSON.stringify(JIT_RandomNumber16Cmd); //转换为json字符串
            return _Getretmsg(JIT_RandomNumber16CmdJson);
        },
        JIT_SymmetricEncryptFromFile_BigData: function (symmkey, uFlag, ORG_DATA, ENC_DATA) {
            //var strFileName1 = ORG_DATA.replace(/\\/g,'\\\\');
            //var strFileName2 = ENC_DATA.replace(/\\/g,'\\\\');
            var JIT_SymmetricEncryptFromFile_BigData_cmd = {
                name: "JIT_SymmetricEncryptFromFile_BigData",
                p1: symmkey,
                p2: uFlag,
                p3: ORG_DATA,
                p4: ENC_DATA
            };
            var JIT_SymmetricEncryptFromFile_BigData_Json = JSON.stringify(JIT_SymmetricEncryptFromFile_BigData_cmd); //转换为json字符串
            //var JIT_SymmetricEncryptFromFile_BigData_cmd = "{\"name\": \"JIT_SymmetricEncryptFromFile_BigData\", \"p1\": \"" + symmkey + "\", \"p2\": \"" + uFlag + "\", \"p3\": \"" + strFileName1 + "\", \"p4\": " + strFileName2 + "}";
            return _Getretcode(JIT_SymmetricEncryptFromFile_BigData_Json);
        },
        JIT_SymmetricDecryptFromFile_BigData: function (strSymmetricKey, uFlag, strEncryptFileName, strSrcFileName) {
            //var strFileName1 = strEncryptFileName.replace(/\\/g,'\\\\');
            //var strFileName2 = strSrcFileName.replace(/\\/g,'\\\\');
            var JIT_SymmetricDecryptFromFile_BigDataCmd = {
                name: "JIT_SymmetricDecryptFromFile_BigData",
                p1: strSymmetricKey,
                p2: uFlag,
                p3: strEncryptFileName,
                p4: strSrcFileName
            };
            var JIT_SymmetricDecryptFromFile_BigDataCmdJson = JSON.stringify(JIT_SymmetricDecryptFromFile_BigDataCmd); //转换为json字符串
            //var JIT_SymmetricDecryptFromFile_BigDataCmd = "{\"name\": \"JIT_SymmetricDecryptFromFile_BigData\", \"p1\": \"" + strSymmetricKey + "\", \"p2\": \"" + uFlag + "\", \"p3\": \"" + strFileName1 + "\", \"p4\": " + strFileName2 + "}";
            return _Getretcode(JIT_SymmetricDecryptFromFile_BigDataCmdJson);
        },
        JITVerifyAttachedSignForRootCert: function (ENC_DATA, CERT_DATA) {
            var JITVerifyAttachedSignForRootCertCmd = {
                name: "JITVerifyAttachedSignStrForRootCert",
                p1: ENC_DATA,
                p2: CERT_DATA
            };
            var JITVerifyAttachedSignForRootCertCmdJson = JSON.stringify(JITVerifyAttachedSignForRootCertCmd); //转换为json字符串
            return _Getretmsg(JITVerifyAttachedSignForRootCertCmdJson);
        },
        JITVerifyDetachedSignForRootCertStr: function (bstrSignedData, bstrSrc, bstrCertBase64) {
            var JITVerifyDetachedSignForRootCertStrCmd = {
                name: "JITVerifyDetachedSignStrForRootCert",
                p1: bstrSignedData,
                p2: bstrSrc,
                p3: bstrCertBase64
            };
            var JITVerifyDetachedSignForRootCertStrCmdJson = JSON.stringify(JITVerifyDetachedSignForRootCertStrCmd); //转换为json字符串
            return _Getretmsg(JITVerifyDetachedSignForRootCertStrCmdJson);
        },
        JITCreateSignedEnvelopStr: function (bstrSignCertDN, bstrEncCertDN, bstrSrc) {
            var JITCreateSignedEnvelopStrCmd = {
                name: "JITCreateSignedEnvelopStr",
                p1: bstrSignCertDN,
                p2: bstrEncCertDN,
                p3: bstrSrc
            };
            var JITCreateSignedEnvelopStrCmdJson = JSON.stringify(JITCreateSignedEnvelopStrCmd); //转换为json字符串
            return _Getretmsg(JITCreateSignedEnvelopStrCmdJson);
        },
        JITCreateSignedEnvelopBase64Str: function (bstrSignCertDN, bstrEncCertDN, bstrSrc,nIsBase64) {
            var JITCreateSignedEnvelopBase64StrCmd = {
                name: "JITCreateSignedEnvelopBase64Str",
                p1: bstrSignCertDN,
                p2: bstrEncCertDN,
                p3: bstrSrc,
                p4: nIsBase64
            };
            var JITCreateSignedEnvelopBase64StrCmdJson = JSON.stringify(JITCreateSignedEnvelopBase64StrCmd); //转换为json字符串
            return _Getretmsg(JITCreateSignedEnvelopBase64StrCmdJson);
        },
        JITVerifySignedEnvelopStr: function (bstrEnvelop) {
            var JITVerifySignedEnvelopStrCmd = {
                name: "JITVerifySignedEnvelopStr",
                p1: bstrEnvelop
            };
            var JITVerifySignedEnvelopStrCmdJson = JSON.stringify(JITVerifySignedEnvelopStrCmd); //转换为json字符串
            return _Getretmsg(JITVerifySignedEnvelopStrCmdJson);
        },
        JITVerifySignedEnvelopStrForRootCert: function (bstrEnvelop, bstrCertInfo) {
            var JITVerifySignedEnvelopStrForRootCertCmd = {
                name: "JITVerifySignedEnvelopStrForRootCert",
                p1: bstrEnvelop,
                p2: bstrCertInfo
            };
            var JITVerifySignedEnvelopStrForRootCertCmdJson = JSON.stringify(JITVerifySignedEnvelopStrForRootCertCmd); //转换为json字符串
            return _Getretmsg(JITVerifySignedEnvelopStrForRootCertCmdJson);
        },
        JIT_AsymmetricEncryptStr: function (bstrPublicKey, nIsPublicKeyCert, bstrSrcData, nIsBase64, nAlgFlag) {
            var JIT_AsymmetricEncryptStrCmd = {
                name: "JIT_AsymmetricEncryptStr",
                p1: bstrPublicKey,
                p2: nIsPublicKeyCert,
                p3: bstrSrcData,
                p4: nIsBase64,
                p5: nAlgFlag
            };
            var JIT_AsymmetricEncryptStrCmdJson = JSON.stringify(JIT_AsymmetricEncryptStrCmd);
            return _Getretmsg(JIT_AsymmetricEncryptStrCmdJson);
        },
        JITChangePinCode: function (bstrPinCode, bstrNewPinCode) {
            var JITChangePinCodeCmd = {
                name: "JITChangePinCode",
                p1: bstrPinCode,
                p2: bstrNewPinCode
            };
            var JITChangePinCodeCmdJson = JSON.stringify(JITChangePinCodeCmd); //转换为json字符串
            return _Getretmsg(JITChangePinCodeCmdJson);
        },

        JITVerifyPinCode: function (bstrPinCode) {
            var JITVerifyPinCodeCmd = {
                name: "JITVerifyPinCode",
                p1: bstrPinCode
            };
            var JITVerifyPinCodeCmdJson = JSON.stringify(JITVerifyPinCodeCmd); //转换为json字符串
            return _Getretmsg(JITVerifyPinCodeCmdJson);
        },
        JIT_DigestStr: function (bstrAlg, bstrSrcData, nIsBase64) {
            var JIT_DigestStrCmd = {
                name: "JIT_DigestStr",
                p1: bstrAlg,
                p2: bstrSrcData,
                p3: nIsBase64
            };
            var JIT_DigestStrCmdJson = JSON.stringify(JIT_DigestStrCmd);
            return _Getretmsg(JIT_DigestStrCmdJson);
        },
        JITGetDLLVersion: function (bstrDLLName, nIsBase64) {
            var JITGetDLLVersionCmd = {
                name: "JITGetDLLVersion",
                p1: bstrDLLName,
                p2: nIsBase64
            };
            var JITGetDLLVersionCmdJson = JSON.stringify(JITGetDLLVersionCmd);
            return _Getretmsg(JITGetDLLVersionCmdJson);
        },
        JIT_AttachSignEx: function (bstrDN, bstrFileName, bstrFileNameOut) {
            var JIT_AttachSignExCmd = {
                name: "JIT_AttachSignEx",
                p1: bstrDN,
                p2: bstrFileName,
                p3: bstrFileNameOut
            };
            var JIT_AttachSignExCmdJson = JSON.stringify(JIT_AttachSignExCmd);
            return _Getretmsg(JIT_AttachSignExCmdJson);
        },
        JIT_DetachSignEx: function (bstrDN, bstrFileName, bstrFileNameOut) {
            var JIT_DetachSignExCmd = {
                name: "JIT_DetachSignEx",
                p1: bstrDN,
                p2: bstrFileName,
                p3: bstrFileNameOut
            };
            var JIT_DetachSignExCmdJson = JSON.stringify(JIT_DetachSignExCmd);
            return _Getretmsg(JIT_DetachSignExCmdJson);
        },
        JIT_VerifyAttachedSignEx: function (bstrFileNameAttached) {
            var JIT_VerifyAttachedSignExCmd = {
                name: "JIT_VerifyAttachedSignEx",
                p1: bstrFileNameAttached
            };
            var JIT_VerifyAttachedSignExCmdJson = JSON.stringify(JIT_VerifyAttachedSignExCmd);
            return _Getretcode(JIT_VerifyAttachedSignExCmdJson);
        },
        JIT_VerifyDetachedSignEx: function (bstrSignedData, bstrFileNameDetached, bstrFileName) {
            var JIT_VerifyDetachedSignExCmd = {
                name: "JIT_VerifyDetachedSignEx",
                p1: bstrSignedData,
                p2: bstrFileNameDetached,
                p3: bstrFileName
            };
            var JIT_VerifyDetachedSignExCmdJson = JSON.stringify(JIT_VerifyDetachedSignExCmd);
            return _Getretcode(JIT_VerifyDetachedSignExCmdJson);
        },
        JIT_EncryptEnvelopEx: function (bstrDN, bstrFileName, bstrFileNameOut) {
            var JIT_EncryptEnvelopExCmd = {
                name: "JIT_EncryptEnvelopEx",
                p1: bstrDN,
                p2: bstrFileName,
                p3: bstrFileNameOut
            };
            var JIT_EncryptEnvelopExCmdJson = JSON.stringify(JIT_EncryptEnvelopExCmd);
            return _Getretmsg(JIT_EncryptEnvelopExCmdJson);
        },
        JIT_DecryptEnvelopEx: function (bstrFileName) {
            var JIT_DecryptEnvelopExCmd = {
                name: "JIT_DecryptEnvelopEx",
                p1: bstrFileName
            };
            var JIT_DecryptEnvelopExCmdJson = JSON.stringify(JIT_DecryptEnvelopExCmd);
            return _Getretcode(JIT_DecryptEnvelopExCmdJson);
        },
        JIT_CreateSignedEnvelopEx: function (bstrSignCertDN, bstrEncCertDN, bstrFileName, bstrFileNameOut) {
            var JIT_CreateSignedEnvelopExCmd = {
                name: "JIT_CreateSignedEnvelopEx",
                p1: bstrSignCertDN,
                p2: bstrEncCertDN,
                p3: bstrFileName,
                p4: bstrFileNameOut
            };
            var JIT_CreateSignedEnvelopExCmdJson = JSON.stringify(JIT_CreateSignedEnvelopExCmd);
            return _Getretmsg(JIT_CreateSignedEnvelopExCmdJson);
        },
        JIT_VerifySignedEnvelopEx: function (bstrEvpFileName) {
            var JIT_VerifySignedEnvelopExCmd = {
                name: "JIT_VerifySignedEnvelopEx",
                p1: bstrEvpFileName
            };
            var JIT_VerifySignedEnvelopExCmdJson = JSON.stringify(JIT_VerifySignedEnvelopExCmd);
            return _Getretcode(JIT_VerifySignedEnvelopExCmdJson);
        },

        JIT_VerifyAttachedSignEx_BigData: function (bstrFileNameAttached, bstrOutFilePath) {
            var JIT_VerifyAttachedSignEx_BigDataCmd = {
                name: "JIT_VerifyAttachedSignEx_BigData",
                p1: bstrFileNameAttached,
                p2: bstrOutFilePath
            };
            var JIT_VerifyAttachedSignEx_BigDataCmdJson = JSON.stringify(JIT_VerifyAttachedSignEx_BigDataCmd);
            return _Getretcode(JIT_VerifyAttachedSignEx_BigDataCmdJson);
        },
        JIT_VerifyDetachedSignEx_BigData: function (bstrSrcFileName, bstrSignFileName) {
            var JIT_VerifyDetachedSignEx_BigDataCmd = {
                name: "JIT_VerifyDetachedSignEx_BigData",
                p1: bstrSrcFileName,
                p2: bstrSignFileName
            };
            var JIT_VerifyDetachedSignEx_BigDataCmdJson = JSON.stringify(JIT_VerifyDetachedSignEx_BigDataCmd);
            return _Getretcode(JIT_VerifyDetachedSignEx_BigDataCmdJson);
        },
        JIT_CreateEnvelopeEx_BigData: function (bstrCertDN, bstrSrcFileName, bstrOutFileName) {
            var JIT_CreateEnvelopeEx_BigDataCmd = {
                name: "JIT_CreateEnvelopeEx_BigData",
                p1: bstrCertDN,
                p2: bstrSrcFileName,
                p3: bstrOutFileName
            };
            var JIT_CreateEnvelopeEx_BigDataCmdJson = JSON.stringify(JIT_CreateEnvelopeEx_BigDataCmd);
            return _Getretcode(JIT_CreateEnvelopeEx_BigDataCmdJson);
        },
        JIT_DigestFromFile: function (stralg, strfilename) {
            var JIT_DigestFromFileCmd = {
                name: "JIT_DigestFromFile",
                p1: stralg,
                p2: strfilename
            };
            var JIT_DigestFromFileCmdJson = JSON.stringify(JIT_DigestFromFileCmd);
            return _Getretmsg(JIT_DigestFromFileCmdJson);
        },
        JITGDigestFromFile: function (stralg, strfilename) {
            var JITGDigestFromFileCmd = {
                name: "JITGDigestFromFile",
                p1: stralg,
                p2: strfilename
            };
            var JITGDigestFromFileCmdJson = JSON.stringify(JITGDigestFromFileCmd);
            return _Getretmsg(JITGDigestFromFileCmdJson);
        },
        JITP1NakeSignStr: function (bstrDN, bstrSrc, nIsBase64, orgName) {
            var JITP1NakeSignStrCmd = {
                name: "JITP1NakeSignStr",
                p1: bstrDN,
                p2: bstrSrc,
                p3: nIsBase64,
                p4: orgName
            };
            var JITP1NakeSignStrCmdJson = JSON.stringify(JITP1NakeSignStrCmd);
            return _Getretmsg(JITP1NakeSignStrCmdJson);
        },
        JIT_P1NakeVerifyStr: function (bstrHashAlg, DSign_Result, DSign_Source, nIsBase64, orgName) {
            var JIT_P1NakeVerifyStrCmd = {
                name: "JIT_P1NakeVerifyStr",
                p1: bstrHashAlg,
                p2: DSign_Result,
                p3: DSign_Source,
                p4: nIsBase64,
                p5: orgName
            };
            var JIT_P1NakeVerifyStrCmdJson = JSON.stringify(JIT_P1NakeVerifyStrCmd);
            return _Getretmsg(JIT_P1NakeVerifyStrCmdJson);
        },
        JITGSymmetricEncryptFromFile_BigData: function (bstrSymmetricKey, uFlag, bstrSrcFileName, bstrOutFileName) {
            var JITGSymmetricEncryptFromFile_BigDataCmd = {
                name: "JITGSymmetricEncryptFromFile_BigData",
                p1: bstrSymmetricKey,
                p2: uFlag,
                p3: bstrSrcFileName,
                p4: bstrOutFileName
            };
            var JITGSymmetricEncryptFromFile_BigDataCmdJson = JSON.stringify(JITGSymmetricEncryptFromFile_BigDataCmd);
            return _Getretmsg(JITGSymmetricEncryptFromFile_BigDataCmdJson);
        },
        JITGSymmetricDecryptFromFile_BigData: function (bstrSymmetricKey, uFlag, bstrSrcFileName, bstrOutFileName) {
            var JITGSymmetricDecryptFromFile_BigDataCmd = {
                name: "JITGSymmetricDecryptFromFile_BigData",
                p1: bstrSymmetricKey,
                p2: uFlag,
                p3: bstrSrcFileName,
                p4: bstrOutFileName
            };
            var JITGSymmetricDecryptFromFile_BigDataCmdJson = JSON.stringify(JITGSymmetricDecryptFromFile_BigDataCmd);
            return _Getretmsg(JITGSymmetricDecryptFromFile_BigDataCmdJson);
        },
        EncryptEnvelopWithOutData_SplitData: function (p1, symmAlg, strSrcFileName, strOutFileName) {
            var EncryptEnvelopWithOutData_SplitDataCmd = {
                name: "EncryptEnvelopWithOutData_SplitData",
                p1: p1,
                p2: symmAlg,
                p3: strSrcFileName,
                p4: strOutFileName
            };
            var EncryptEnvelopWithOutData_SplitDataCmdJson = JSON.stringify(EncryptEnvelopWithOutData_SplitDataCmd);
            return _Getretmsg(EncryptEnvelopWithOutData_SplitDataCmdJson);
        },
        DecryptEnvelopWithOutData_SplitData: function (symmAlg,strInFileName, envelopResult, strOutFileName) {
            var DecryptEnvelopWithOutData_SplitDataCmd = {
                name: "DecryptEnvelopWithOutData_SplitData",
                p1: symmAlg,
                p2: strInFileName,
                p3: envelopResult,
                p4: strOutFileName
            };
            var DecryptEnvelopWithOutData_SplitDataCmdJson = JSON.stringify(DecryptEnvelopWithOutData_SplitDataCmd);
            return _Getretmsg(DecryptEnvelopWithOutData_SplitDataCmdJson);
        },
        SetSeekFlag: function (flag) {
            var SetSeekFlagCmd = {
                name: "SetSeekFlag",
                p1: flag
            };
            var SetSeekFlagCmdJson = JSON.stringify(SetSeekFlagCmd);
            return _Getretmsg(SetSeekFlagCmdJson);
        },
        SignDataXMLStr: function (p1,p2,ORG_DATA) {
            var SignDataXMLStrCmd = {
                name: "SignDataXMLStr",
                p1: p1,
                p2: p2,
                p3: ORG_DATA
            };
            var SignDataXMLStrCmdJson = JSON.stringify(SignDataXMLStrCmd);
            return _Getretmsg(SignDataXMLStrCmdJson);
        },
        VerifySignedDataXML: function (p1,p2,p3,ORG_DATA) {
            var VerifySignedDataXMLCmd = {
                name: "VerifySignedDataXML",
                p1: p1,
                p2: p2,
                p3: p3,
                p4: ORG_DATA
            };
            var VerifySignedDataXMLCmdJson = JSON.stringify(VerifySignedDataXMLCmd);
            return _Getretmsg(VerifySignedDataXMLCmdJson);
        },
        JIT_SymmetricEncrypt: function (strSymmetricKey, strEncryptData, uFlag) {
            var JIT_SymmetricEncryptCmd = {
                name: "JIT_SymmetricEncrypt",
                p1: strSymmetricKey,
                p2: strEncryptData,
                p3: uFlag
            };
            var JIT_SymmetricEncryptCmdJson = JSON.stringify(JIT_SymmetricEncryptCmd);
            return _Getretmsg(JIT_SymmetricEncryptCmdJson);
        },
        JIT_SymmetricEncryptBase64Str: function (strSymmetricKey, strEncryptData, nIsBase64,uFlag) {
            var JIT_SymmetricEncryptBase64StrCmd = {
                name: "JIT_SymmetricEncryptBase64Str",
                p1: strSymmetricKey,
                p2: strEncryptData,
                p3: nIsBase64,
                p4: uFlag
            };
            var JIT_SymmetricEncryptBase64StrCmdJson = JSON.stringify(JIT_SymmetricEncryptBase64StrCmd);
            return _Getretmsg(JIT_SymmetricEncryptBase64StrCmdJson);
        },
        JIT_SymmetricDecrypt: function (strSymmetricKey, strEncryptData, uFlag) {
            var JIT_SymmetricDecryptCmd = {
                name: "JIT_SymmetricDecrypt",
                p1: strSymmetricKey,
                p2: strEncryptData,
                p3: uFlag
            };
            var JIT_SymmetricDecryptCmdJson = JSON.stringify(JIT_SymmetricDecryptCmd);
            return _Getretmsg(JIT_SymmetricDecryptCmdJson);
        },
        CloseAppWhenPullKey: function (bstrAppname) {
            var CloseAppWhenPullKeyCmd = {
                name: "CloseAppWhenPullKey",
                p1: bstrAppname
            };
            var CloseAppWhenPullKeyCmdJson = JSON.stringify(CloseAppWhenPullKeyCmd);
            return _Getretcode(CloseAppWhenPullKeyCmdJson);
        },
        JITGSymmetricEncryptByIV: function (bstrIV,strSymmetricKey, strSrcData, uFlag) {
            var JITGSymmetricEncryptByIVCmd = {
                name: "JITGSymmetricEncryptByIV",
                p1: bstrIV,
                p2: strSymmetricKey,
                p3: strSrcData,
                p4: uFlag
            };
            var JITGSymmetricEncryptByIVCmdJson = JSON.stringify(JITGSymmetricEncryptByIVCmd);
            return _Getretmsg(JITGSymmetricEncryptByIVCmdJson);
        },
        JITGSymmetricEncryptByIVBase64Str: function (bstrIV,strSymmetricKey, strSrcData, nIsBase64,uFlag) {
            var JITGSymmetricEncryptByIVBase64StrCmd = {
                name: "JITGSymmetricEncryptByIVBase64Str",
                p1: bstrIV,
                p2: strSymmetricKey,
                p3: strSrcData,
                p4: nIsBase64,
                p5: uFlag
            };
            var JITGSymmetricEncryptByIVBase64StrCmdJson = JSON.stringify(JITGSymmetricEncryptByIVBase64StrCmd);
            return _Getretmsg(JITGSymmetricEncryptByIVBase64StrCmdJson);
        },
        JITGSymmetricDecryptByIV: function (bstrIV,strSymmetricKey, strSrcData, uFlag) {
            var JITGSymmetricDecryptByIVCmd = {
                name: "JITGSymmetricDecryptByIV",
                p1: bstrIV,
                p2: strSymmetricKey,
                p3: strSrcData,
                p4: uFlag
            };
            var JITGSymmetricDecryptByIVCmdJson = JSON.stringify(JITGSymmetricDecryptByIVCmd);
            return _Getretmsg(JITGSymmetricDecryptByIVCmdJson);
        },
        JITGSymmetricEncryptFromFile_BigDataByIV: function (bstrIV,strSymmetricKey, uFlag,Result_File_Name,Sel_File_Name) {
            var JITGSymmetricEncryptFromFile_BigDataByIVCmd = {
                name: "JITGSymmetricEncryptFromFile_BigDataByIV",
                p1: bstrIV,
                p2: strSymmetricKey,
                p3: uFlag,
                p4: Result_File_Name,
                p5:Sel_File_Name
            };
            var JITGSymmetricEncryptFromFile_BigDataByIVCmdJson = JSON.stringify(JITGSymmetricEncryptFromFile_BigDataByIVCmd);
            return _Getretmsg(JITGSymmetricEncryptFromFile_BigDataByIVCmdJson);
        },
        JITGSymmetricDecryptFromFile_BigDataByIV: function (bstrIV,strSymmetricKey, uFlag,Sel_File_Name,Result_File_Name) {
            var JITGSymmetricDecryptFromFile_BigDataByIVCmd = {
                name: "JITGSymmetricDecryptFromFile_BigDataByIV",
                p1: bstrIV,
                p2: strSymmetricKey,
                p3: uFlag,
                p4: Sel_File_Name ,
                p5: Result_File_Name
            };
            var JITGSymmetricDecryptFromFile_BigDataByIVCmdJson = JSON.stringify(JITGSymmetricDecryptFromFile_BigDataByIVCmd);
            return _Getretmsg(JITGSymmetricDecryptFromFile_BigDataByIVCmdJson);
        },
        JIT_SymmetricEncryptByIV: function (bstrIV,strSymmetricKey, strSrcData, uFlag) {
            var JIT_SymmetricEncryptByIVCmd = {
                name: "JIT_SymmetricEncryptByIV",
                p1: bstrIV,
                p2: strSymmetricKey,
                p3: strSrcData,
                p4: uFlag
            };
            var JIT_SymmetricEncryptByIVCmdJson = JSON.stringify(JIT_SymmetricEncryptByIVCmd);
            return _Getretmsg(JIT_SymmetricEncryptByIVCmdJson);
        },
        JIT_SymmetricEncryptByIVBase64Str: function (bstrIV,strSymmetricKey, strSrcData, nIsBase64,uFlag) {
            var JIT_SymmetricEncryptByIVBase64StrCmd = {
                name: "JIT_SymmetricEncryptByIVBase64Str",
                p1: bstrIV,
                p2: strSymmetricKey,
                p3: strSrcData,
                p4: nIsBase64,
                p5: uFlag
            };
            var JIT_SymmetricEncryptByIVBase64StrCmdJson = JSON.stringify(JIT_SymmetricEncryptByIVBase64StrCmd);
            return _Getretmsg(JIT_SymmetricEncryptByIVBase64StrCmdJson);
        },
        JIT_SymmetricDecryptByIV: function (bstrIV,strSymmetricKey, strSrcData, uFlag) {
            var JIT_SymmetricDecryptByIVCmd = {
                name: "JIT_SymmetricDecryptByIV",
                p1: bstrIV,
                p2: strSymmetricKey,
                p3: strSrcData,
                p4: uFlag
            };
            var JIT_SymmetricDecryptByIVCmdJson = JSON.stringify(JIT_SymmetricDecryptByIVCmd);
            return _Getretmsg(JIT_SymmetricDecryptByIVCmdJson);
        },
        JIT_SymmetricEncryptFromFile_BigDataByIV: function (bstrIV,strSymmetricKey, uFlag,Sel_File_Name,Result_File_Name) {
            var JIT_SymmetricEncryptFromFile_BigDataByIVCmd = {
                name: "JIT_SymmetricEncryptFromFile_BigDataByIV",
                p1: bstrIV,
                p2: strSymmetricKey,
                p3: uFlag,
                p4: Sel_File_Name,
                p5: Result_File_Name
            };
            var JIT_SymmetricEncryptFromFile_BigDataByIVCmdJson = JSON.stringify(JIT_SymmetricEncryptFromFile_BigDataByIVCmd);
            return _Getretmsg(JIT_SymmetricEncryptFromFile_BigDataByIVCmdJson);
        },
        JIT_SymmetricDecryptFromFile_BigDataByIV: function (bstrIV,strSymmetricKey, uFlag,Sel_File_Name,Result_File_Name) {
            var JIT_SymmetricDecryptFromFile_BigDataByIVCmd = {
                name: "JIT_SymmetricDecryptFromFile_BigDataByIV",
                p1: bstrIV,
                p2: strSymmetricKey,
                p3: uFlag,
                p4: Sel_File_Name,
                p5: Result_File_Name
            };
            var JIT_SymmetricDecryptFromFile_BigDataByIVCmdJson = JSON.stringify(JIT_SymmetricDecryptFromFile_BigDataByIVCmd);
            return _Getretmsg(JIT_SymmetricDecryptFromFile_BigDataByIVCmdJson);
        },
        JIT_P1VerifyStr: function (bstrHashAlg,DSign_Result,DSign_Source,nIsBase64,DSign_Cert) {
            var JIT_P1VerifyStrCmd = {
                name: "JIT_P1VerifyStr",
                p1: bstrHashAlg,
                p2: DSign_Result,
                p3: DSign_Source,
                p4: nIsBase64,
                p5: DSign_Cert
            };
            var JIT_P1VerifyStrCmdJson = JSON.stringify(JIT_P1VerifyStrCmd);
            return _Getretmsg(JIT_P1VerifyStrCmdJson);
        },
        SetCert4: function (bstrCertType,bstrDN, bstrSN,bstrEmail,bstrDNIssuer,bstrCertBase64) {
            var SetCert4Cmd = {
                name: "SetCert4",
                p1: bstrCertType,
                p2: bstrDN,
                p3: bstrSN,
                p4: bstrEmail,
                p5: bstrDNIssuer,
                p6:bstrCertBase64
            };
            var SetCert4CmdJson = JSON.stringify(SetCert4Cmd);
            return _Getretcode(SetCert4CmdJson);
        },
        SetCert5: function (bstrCertType,bstrDN, bstrSN,bstrEmail,bstrDNIssuer,bstrCertBase64,bstrCertNameType) {
            var SetCert5Cmd = {
                name: "SetCert5",
                p1: bstrCertType,
                p2: bstrDN,
                p3: bstrSN,
                p4: bstrEmail,
                p5: bstrDNIssuer,
                p6:bstrCertBase64,
                p7:bstrCertNameType
            };
            var SetCert5CmdJson = JSON.stringify(SetCert5Cmd);
            return _Getretcode(SetCert5CmdJson);
        },
        GetCertLists1: function (bstrCertType,bstrCertDN, bstrCertSN,bstrCertEmail,bstrCertIssuerDN,lInfoType) {
            var GetCertLists1Cmd = {
                name: "GetCertLists1",
                p1: bstrCertType,
                p2: bstrCertDN,
                p3: bstrCertSN,
                p4: bstrCertEmail,
                p5: bstrCertIssuerDN,
                P6: lInfoType
            };
            var GetCertLists1CmdJson = JSON.stringify(GetCertLists1Cmd);
            return _Getretmsg(GetCertLists1CmdJson);
        },
        JITGetClientIP: function () {
            var JITGetClientIPCmd = {
                name: "JITGetClientIP"
            };
            var JITGetClientIPCmdJson = JSON.stringify(JITGetClientIPCmd);
            return _Getretmsg(JITGetClientIPCmdJson);
        },

        EncryptEnvelopWithOutData_SplitData1: function (bstrDN,bstrSymmAlg, bstrFileName,bstrFileNameOut) {
            var EncryptEnvelopWithOutData_SplitData1Cmd = {
                name: "EncryptEnvelopWithOutData_SplitData1",
                p1: bstrDN,
                p2: bstrSymmAlg,
                p3: bstrFileName,
                p4: bstrFileNameOut
            };
            var EncryptEnvelopWithOutData_SplitData1CmdJson = JSON.stringify(EncryptEnvelopWithOutData_SplitData1Cmd);
            return _Getretmsg(EncryptEnvelopWithOutData_SplitData1CmdJson);
        },
        DecryptEnvelopWithOutData_SplitData1: function (bstrSymmAlg,bstrFileName, bstrEvpDataB64,bstrSrcFilePath) {
            var DecryptEnvelopWithOutData_SplitData1Cmd = {
                name: "DecryptEnvelopWithOutData_SplitData1",
                p1: bstrSymmAlg,
                p2: bstrFileName,
                p3: bstrEvpDataB64,
                p4: bstrSrcFilePath
            };
            var DecryptEnvelopWithOutData_SplitData1CmdJson = JSON.stringify(DecryptEnvelopWithOutData_SplitData1Cmd);
            return _Getretmsg(DecryptEnvelopWithOutData_SplitData1CmdJson);
        },
        JITGGetBase64EncodeFromFile: function (bstrSrcFileName,bstrOutFileName) {
            var JITGGetBase64EncodeFromFileCmd = {
                name: "JITGGetBase64EncodeFromFile",
                p1: bstrSrcFileName,
                p2: bstrOutFileName
            };
            var JITGGetBase64EncodeFromFileCmdJson = JSON.stringify(JITGGetBase64EncodeFromFileCmd);
            return _Getretcode(JITGGetBase64EncodeFromFileCmdJson);
        },
        JITGGetBase64DecodeFromFile: function (bstrSrcFileName,bstrOutFileName) {
            var JITGGetBase64DecodeFromFileCmd = {
                name: "JITGGetBase64DecodeFromFile",
                p1: bstrSrcFileName,
                p2: bstrOutFileName
            };
            var JITGGetBase64DecodeFromFileCmdJson = JSON.stringify(JITGGetBase64DecodeFromFileCmd);
            return _Getretcode(JITGGetBase64DecodeFromFileCmdJson);
        },
        GetBase64EncodeStr: function (pszSrcData) {
            var GetBase64EncodeStrCmd = {
                name: "GetBase64EncodeStr",
                p1: pszSrcData
            };
            var GetBase64EncodeStrCmdJson = JSON.stringify(GetBase64EncodeStrCmd);
            return _Getretmsg(GetBase64EncodeStrCmdJson);
        },
        GetBase64DecodeStr: function (bstrBase64Data) {
            var GetBase64DecodeStrCmd = {
                name: "GetBase64DecodeStr",
                p1: bstrBase64Data
            };
            var GetBase64DecodeStrCmdJson = JSON.stringify(GetBase64DecodeStrCmd);
            return _Getretmsg(GetBase64DecodeStrCmdJson);
        },
        VerifyDetachedSignBase64Str: function (bstrSignedData,bstrSrc,nIsBase64) {
            var VerifyDetachedSignBase64StrCmd = {
                name: "VerifyDetachedSignBase64Str",
                p1: bstrSignedData,
                p2: bstrSrc,
                p3: nIsBase64
            };
            var VerifyDetachedSignBase64StrCmdJson = JSON.stringify(VerifyDetachedSignBase64StrCmd);
            return _Getretcode(VerifyDetachedSignBase64StrCmdJson);
        },
        JITGVerifyDetachedSignBase64Str: function (bstrSignedData,bstrSrc,nIsBase64) {
            var JITGVerifyDetachedSignBase64StrCmd = {
                name: "JITGVerifyDetachedSignBase64Str",
                p1: bstrSignedData,
                p2: bstrSrc,
                p3: nIsBase64
            };
            var JITGVerifyDetachedSignBase64StrCmdJson = JSON.stringify(JITGVerifyDetachedSignBase64StrCmd);
            return _Getretcode(JITGVerifyDetachedSignBase64StrCmdJson);
        },
        MOF_VerifyDetachedSignBase64Str: function (DSign_Result,DSign_Source) {
            var MOF_VerifyDetachedSignBase64StrCmd = {
                name: "MOF_VerifyDetachedSignBase64Str",
                p1: DSign_Result,
                p2: DSign_Source
            };
            var MOF_VerifyDetachedSignBase64StrCmdJson = JSON.stringify(MOF_VerifyDetachedSignBase64StrCmd);
            return _Getretcode(MOF_VerifyDetachedSignBase64StrCmdJson);
        },
        JITVerifyDetachedSignForRootCertBase64Str: function (bstrSignedData,bstrSrc,nIsBase64,bstrCertBase64) {
            var JITVerifyDetachedSignForRootCertBase64StrCmd = {
                name: "JITVerifyDetachedSignForRootCertBase64Str",
                p1: bstrSignedData,
                p2: bstrSrc,
                p3:nIsBase64,
                p4:bstrCertBase64
            };
            var JITVerifyDetachedSignForRootCertBase64StrCmdJson = JSON.stringify(JITVerifyDetachedSignForRootCertBase64StrCmd);
            return _Getretcode(JITVerifyDetachedSignForRootCertBase64StrCmdJson);
        }
        // ,
        // SOF_GetVersion: function () {
        //     var  SOF_GetVersionCmd = {
        //         name: "SOF_GetVersion"
        //     };
        //     var SOF_GetVersionCmdJson = JSON.stringify(SOF_GetVersionCmd);
        //     return _Getretmsg(SOF_GetVersionCmdJson);
        // },
        // SOF_SetSignMethod: function (lSignAlg) {
        //     var SOF_SetSignMethodCmd = {
        //         name: "SOF_SetSignMethod",
        //         p1: lSignAlg
        //     };
        //     var SOF_SetSignMethodCmdJson = JSON.stringify(SOF_SetSignMethodCmd);
        //     return _Getretmsg(SOF_SetSignMethodCmdJson);
        // },
        // SOF_GetSignMethod: function () {
        //     var SOF_GetSignMethodCmd = {
        //         name: "SOF_GetSignMethod"
        //     };
        //     var SOF_GetSignMethodCmdJson = JSON.stringify(SOF_GetSignMethodCmd);
        //     return _Getretmsg(SOF_GetSignMethodCmdJson);
        // },
        // SOF_SetEncryptMethod: function (lEncAlg) {
        //     var SOF_SetEncryptMethodCmd = {
        //         name: "SOF_SetEncryptMethod",
        //         p1: lEncAlg
        //     };
        //     var SOF_SetEncryptMethodCmdJson = JSON.stringify(SOF_SetEncryptMethodCmd);
        //     return _Getretmsg(SOF_SetEncryptMethodCmdJson);
        // },
        // SOF_GetEncryptMethod: function () {
        //     var SOF_GetEncryptMethodCmd = {
        //         name: "SOF_GetEncryptMethod"
        //     };
        //     var SOF_GetEncryptMethodCmdJson = JSON.stringify(SOF_GetEncryptMethodCmd);
        //     return _Getretmsg(SOF_GetEncryptMethodCmdJson);
        // },
        // SOF_GetUserList: function () {
        //     var SOF_GetUserListCmd = {
        //         name: "SOF_GetUserList"
        //     };
        //     var SOF_GetUserListCmdJson = JSON.stringify(SOF_GetUserListCmd);
        //     return _Getretmsg(SOF_GetUserListCmdJson);
        // },
        // SOF_ChangePassWd: function (CertSN, old_pin, new_pin) {
        //     var SOF_ChangePassWdCmd = {
        //         name: "SOF_ChangePassWd",
        //         p1: CertSN,
        //         p2: old_pin,
        //         p3: new_pin
        //     };
        //     var SOF_ChangePassWdCmdJson = JSON.stringify(SOF_ChangePassWdCmd);
        //     return _Getretmsg(SOF_ChangePassWdCmdJson);
        // },
        // SOF_Login: function (CertSN, pin) {
        //     var SOF_LoginCmd = {
        //         name: "SOF_Login",
        //         p1: CertSN,
        //         p2: pin
        //
        //     };
        //     var SOF_LoginCmdJson = JSON.stringify(SOF_LoginCmd);
        //     return _Getretmsg(SOF_LoginCmdJson);
        // },
        // SOF_ExportUserCert: function (CertSN) {
        //     var SOF_ExportUserCertCmd = {
        //         name: "SOF_ExportUserCert",
        //         p1: CertSN
        //     };
        //     var SOF_ExportUserCertCmdJson = JSON.stringify(SOF_ExportUserCertCmd);
        //     return _Getretmsg(SOF_ExportUserCertCmdJson);
        // },
        // SOF_ExportExChangeUserCert: function (CertSN) {
        //     var SOF_ExportExChangeUserCertCmd = {
        //         name: "SOF_ExportExChangeUserCert",
        //         p1: CertSN
        //     };
        //     var SOF_ExportExChangeUserCertCmdJson = JSON.stringify(SOF_ExportExChangeUserCertCmd);
        //     return _Getretmsg(SOF_ExportExChangeUserCertCmdJson);
        // },
        //
        //
        // SOF_ValidateCert: function (CERT_DATA) {
        //     var SOF_ValidateCertCmd = {
        //         name: "SOF_ValidateCert",
        //         p1: CERT_DATA
        //     };
        //     var SOF_ValidateCertCmdJson = JSON.stringify(SOF_ValidateCertCmd);
        //     return _Getretmsg(SOF_ValidateCertCmdJson);
        // },
        // SOF_GetCertInfo: function (CERT_DATA, certTypeList) {
        //     var SOF_GetCertInfoCmd = {
        //         name: "SOF_GetCertInfo",
        //         p1: CERT_DATA,
        //         p2: certTypeList
        //     };
        //     var SOF_GetCertInfoCmdJson = JSON.stringify(SOF_GetCertInfoCmd);
        //     return _Getretmsg(SOF_GetCertInfoCmdJson);
        // },
        // SOF_GetCertInfoByOid: function (CERT_DATA, OID) {
        //     var SOF_GetCertInfoByOidCmd = {
        //         name: "SOF_GetCertInfoByOid",
        //         p1: CERT_DATA,
        //         p2: OID
        //     };
        //     var SOF_GetCertInfoByOidCmdJson = JSON.stringify(SOF_GetCertInfoByOidCmd);
        //     return _Getretmsg(SOF_GetCertInfoByOidCmdJson);
        // },
        // SOF_GetUserInfo: function (CERT_DATA, OrgData) {
        //     var SOF_GetUserInfoCmd = {
        //         name: "SOF_GetUserInfo",
        //         p1: CERT_DATA,
        //         p2: OrgData
        //     };
        //     var SOF_GetUserInfoCmdJson = JSON.stringify(SOF_GetUserInfoCmd);
        //     return _Getretmsg(SOF_GetUserInfoCmdJson);
        // },
        // SOF_SignData: function (CertSN, OrgData) {
        //     var SOF_SignDataCmd = {
        //         name: "SOF_SignData",
        //         p1: CertSN,
        //         p2: OrgData
        //     };
        //     var SOF_SignDataCmdJson = JSON.stringify(SOF_SignDataCmd);
        //     return _Getretmsg(SOF_SignDataCmdJson);
        // },
        // SOF_VerifySignedData: function (CERT_DATA, OrgData,Content_Result) {
        //     var SOF_VerifySignedDataCmd = {
        //         name: "SOF_VerifySignedData",
        //         p1: CERT_DATA,
        //         p2: OrgData,
        //         p2: Content_Result
        //     };
        //     var SOF_VerifySignedDataCmdJson = JSON.stringify(SOF_VerifySignedDataCmd);
        //     return _Getretmsg(SOF_VerifySignedDataCmdJson);
        // },
        // SOF_SignFile: function (CertSN, File_Name) {
        //     var SOF_SignFileCmd = {
        //         name: "SOF_SignFile",
        //         p1: CertSN,
        //         p2: File_Name
        //     };
        //     var SOF_SignFileCmdJson = JSON.stringify(SOF_SignFileCmd);
        //     return _Getretmsg(SOF_SignFileCmdJson);
        // },
        // SOF_VerifySignedFile: function (CERT_DATA, File_Name, DSign_Result) {
        //     var SOF_VerifySignedFileCmd = {
        //         name: "SOF_VerifySignedFile",
        //         p1: CERT_DATA,
        //         p2: File_Name,
        //         p3:DSign_Result
        //     };
        //     var SOF_VerifySignedFileCmdJson = JSON.stringify(SOF_VerifySignedFileCmd);
        //     return _Getretmsg(SOF_VerifySignedFileCmdJson);
        // },
        // SOF_SignDataByP7: function (strCertSN, DSign_Content) {
        //     var SOF_SignDataByP7Cmd = {
        //         name: "SOF_SignDataByP7",
        //         p1: strCertSN,
        //         p2: DSign_Content
        //     };
        //     var SOF_SignDataByP7CmdJson = JSON.stringify(SOF_SignDataByP7Cmd);
        //     return _Getretmsg(SOF_SignDataByP7CmdJson);
        // },
        // SOF_VerifySignedDataByP7: function (strCertSN, DSign_Content) {
        //     var SOF_VerifySignedDataByP7Cmd = {
        //         name: "SOF_VerifySignedDataByP7",
        //         p1: strCertSN,
        //         p2: DSign_Content
        //     };
        //     var SOF_VerifySignedDataByP7CmdJson = JSON.stringify(SOF_VerifySignedDataByP7Cmd);
        //     return _Getretmsg(SOF_VerifySignedDataByP7CmdJson);
        // },
        // SOF_GetP7SignDataInfo: function (p7SignData) {
        //     var SOF_GetP7SignDataInfoCmd = {
        //         name: "SOF_GetP7SignDataInfo",
        //         p1: p7SignData
        //     };
        //     var SOF_GetP7SignDataInfoCmdJson = JSON.stringify(SOF_GetP7SignDataInfoCmd);
        //     return _Getretmsg(SOF_GetP7SignDataInfoCmdJson);
        // },
        // SOF_EncryptData: function (key,orgData) {
        //     var SOF_EncryptDataCmd = {
        //         name: "SOF_EncryptData",
        //         p1: key,
        //         p2: orgData
        //     };
        //     var SOF_EncryptDataCmdJson = JSON.stringify(SOF_EncryptDataCmd);
        //     return _Getretmsg(SOF_EncryptDataCmdJson);
        // },
        // SOF_DecryptData: function (key,orgData) {
        //     var SOF_DecryptDataCmd = {
        //         name: "SOF_DecryptData",
        //         p1: key,
        //         p2: orgData
        //     };
        //     var SOF_DecryptDataCmdJson = JSON.stringify(SOF_DecryptDataCmd);
        //     return _Getretmsg(SOF_DecryptDataCmdJson);
        // },
        // SOF_EncryptFile: function (key,In_File_Name,Out_File_Name) {
        //     var SOF_EncryptFileCmd = {
        //         name: "SOF_EncryptFile",
        //         p1: key,
        //         p2: In_File_Name,
        //         p3: Out_File_Name
        //     };
        //     var SOF_EncryptFileCmdJson = JSON.stringify(SOF_EncryptFileCmd);
        //     return _Getretmsg(SOF_EncryptFileCmdJson);
        // },
        // SOF_DecryptFile: function (key,In_File_Name,Out_File_Name) {
        //     var SOF_DecryptFileCmd = {
        //         name: "SOF_DecryptFile",
        //         p1: key,
        //         p2: In_File_Name,
        //         p3: Out_File_Name
        //     };
        //     var SOF_DecryptFileCmdJson = JSON.stringify(SOF_DecryptFileCmd);
        //     return _Getretmsg(SOF_DecryptFileCmdJson);
        // },
        // SOF_SignDataXML: function (CertSN,OrgData) {
        //     var SOF_SignDataXMLCmd = {
        //         name: "SOF_SignDataXML",
        //         p1: CertSN,
        //         p2: OrgData
        //     };
        //     var SOF_SignDataXMLCmdJson = JSON.stringify(SOF_SignDataXMLCmd);
        //     return _Getretmsg(SOF_SignDataXMLCmdJson);
        // },
        // SOF_VerifySignedDataXML: function (xmlSignData) {
        //     var SOF_VerifySignedDataXMLCmd = {
        //         name: "SOF_VerifySignedDataXML",
        //         p1: xmlSignData
        //     };
        //     var SOF_VerifySignedDataXMLCmdJson = JSON.stringify(SOF_VerifySignedDataXMLCmd);
        //     return _Getretmsg(SOF_VerifySignedDataXMLCmdJson);
        // },
        // SOF_GetXMLSignatureInfo: function (xmlSignData,info_id) {
        //     var SOF_GetXMLSignatureInfoCmd = {
        //         name: "SOF_GetXMLSignatureInfo",
        //         p1: xmlSignData,
        //         p2: info_id
        //     };
        //     var SOF_GetXMLSignatureInfoCmdJson = JSON.stringify(SOF_GetXMLSignatureInfoCmd);
        //     return _Getretmsg(SOF_GetXMLSignatureInfoCmdJson);
        // },
        // GetLastError: function () {
        //     var SOF_GetLastErrorCmd = {
        //         name: "GetLastError"
        //     };
        //     var SOF_GetLastErrorCmdJson = JSON.stringify(SOF_GetLastErrorCmd);
        //     return _Getretmsg(SOF_GetLastErrorCmdJson);
        // },
        // SOF_GenRandom: function (OrgData) {
        //     var SOF_GenRandomCmd = {
        //         name: "SOF_GenRandom",
        //         p1: OrgData
        //     };
        //     var SOF_GenRandomCmdJson = JSON.stringify(SOF_GenRandomCmd);
        //     return _Getretmsg(SOF_GenRandomCmdJson);
        // }

    }
}
export default new JITHTTPCLIENT('JITHTTPCLIENT');